MemoryStream Třída

Definice

Obor názvů:

System.IO

Sestavení:

System.Runtime.dll

Zdroj:

MemoryStream.cs

Vytvoří datový proud, jehož záložní úložiště je paměť.

public ref class MemoryStream : System::IO::Stream

public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Dědičnost

Object

MarshalByRefObject

Stream

MemoryStream

Příklady

Následující příklad kódu ukazuje, jak číst a zapisovat data pomocí paměti jako záložní úložiště.

using namespace System;
using namespace System::IO;
using namespace System::Text;

int main()
{
   int count;
   array<Byte>^byteArray;
   array<Char>^charArray;
   UnicodeEncoding^ uniEncoding = gcnew UnicodeEncoding;

   // Create the data to write to the stream.
   array<Byte>^firstString = uniEncoding->GetBytes( "Invalid file path characters are: " );
   array<Byte>^secondString = uniEncoding->GetBytes( Path::InvalidPathChars );

   MemoryStream^ memStream = gcnew MemoryStream( 100 );
   try
   {
      // Write the first string to the stream.
      memStream->Write( firstString, 0, firstString->Length );

      // Write the second string to the stream, byte by byte.
      count = 0;
      while ( count < secondString->Length )
      {
         memStream->WriteByte( secondString[ count++ ] );
      }

      
      // Write the stream properties to the console.
      Console::WriteLine( "Capacity = {0}, Length = {1}, "
      "Position = {2}\n", memStream->Capacity.ToString(), memStream->Length.ToString(), memStream->Position.ToString() );

      // Set the stream position to the beginning of the stream.
      memStream->Seek( 0, SeekOrigin::Begin );

      // Read the first 20 bytes from the stream.
      byteArray = gcnew array<Byte>(memStream->Length);
      count = memStream->Read( byteArray, 0, 20 );

      // Read the remaining bytes, byte by byte.
      while ( count < memStream->Length )
      {
         byteArray[ count++ ] = Convert::ToByte( memStream->ReadByte() );
      }
      
      // Decode the Byte array into a Char array 
      // and write it to the console.
      charArray = gcnew array<Char>(uniEncoding->GetCharCount( byteArray, 0, count ));
      uniEncoding->GetDecoder()->GetChars( byteArray, 0, count, charArray, 0 );
      Console::WriteLine( charArray );
   }
   finally
   {
      memStream->Close();
   }
}

using System;
using System.IO;
using System.Text;

class MemStream
{
    static void Main()
    {
        int count;
        byte[] byteArray;
        char[] charArray;
        UnicodeEncoding uniEncoding = new UnicodeEncoding();

        // Create the data to write to the stream.
        byte[] firstString = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        byte[] secondString = uniEncoding.GetBytes(
            Path.GetInvalidPathChars());

        using(MemoryStream memStream = new MemoryStream(100))
        {
            // Write the first string to the stream.
            memStream.Write(firstString, 0 , firstString.Length);

            // Write the second string to the stream, byte by byte.
            count = 0;
            while(count < secondString.Length)
            {
                memStream.WriteByte(secondString[count++]);
            }

            // Write the stream properties to the console.
            Console.WriteLine(
                "Capacity = {0}, Length = {1}, Position = {2}\n",
                memStream.Capacity.ToString(),
                memStream.Length.ToString(),
                memStream.Position.ToString());

            // Set the position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin);

            // Read the first 20 bytes from the stream.
            byteArray = new byte[memStream.Length];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte.
            while(count < memStream.Length)
            {
                byteArray[count++] = (byte)memStream.ReadByte();
            }

            // Decode the byte array into a char array
            // and write it to the console.
            charArray = new char[uniEncoding.GetCharCount(
                byteArray, 0, count)];
            uniEncoding.GetDecoder().GetChars(
                byteArray, 0, count, charArray, 0);
            Console.WriteLine(charArray);
        }
    }
}

Imports System.IO
Imports System.Text

Module MemStream

    Sub Main()
    
        Dim count As Integer
        Dim byteArray As Byte()
        Dim charArray As Char()
        Dim uniEncoding As New UnicodeEncoding()

        ' Create the data to write to the stream.
        Dim firstString As Byte() = _
            uniEncoding.GetBytes("Invalid file path characters are: ")
        Dim secondString As Byte() = _
            uniEncoding.GetBytes(Path.GetInvalidPathChars())

        Dim memStream As New MemoryStream(100)
        Try
            ' Write the first string to the stream.
            memStream.Write(firstString, 0 , firstString.Length)

            ' Write the second string to the stream, byte by byte.
            count = 0
            While(count < secondString.Length)
                memStream.WriteByte(secondString(count))
                count += 1
            End While
            
            ' Write the stream properties to the console.
            Console.WriteLine( _
                "Capacity = {0}, Length = {1}, Position = {2}", _
                memStream.Capacity.ToString(), _
                memStream.Length.ToString(), _
                memStream.Position.ToString())

            ' Set the stream position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin)

            ' Read the first 20 bytes from the stream.
            byteArray = _
                New Byte(CType(memStream.Length, Integer)){}
            count = memStream.Read(byteArray, 0, 20)

            ' Read the remaining Bytes, Byte by Byte.
            While(count < memStream.Length)
                byteArray(count) = _
                    Convert.ToByte(memStream.ReadByte())
                count += 1
            End While

            ' Decode the Byte array into a Char array 
            ' and write it to the console.
            charArray = _
                New Char(uniEncoding.GetCharCount( _
                byteArray, 0, count)){}
            uniEncoding.GetDecoder().GetChars( _
                byteArray, 0, count, charArray, 0)
            Console.WriteLine(charArray)
        Finally
            memStream.Close()
        End Try

    End Sub
End Module

Poznámky

Aktuální pozice datového proudu je pozice, ve které může proběhnout další operace čtení nebo zápisu. Aktuální pozici lze načíst nebo nastavit pomocí metody Seek. Při vytvoření nové instance MemoryStream je aktuální pozice nastavena na nulu.

Poznámka

Tento typ implementuje rozhraní IDisposable, ale ve skutečnosti nemá žádné prostředky k odstranění. To znamená, že jeho odstranění přímým voláním Dispose() nebo použitím konstruktoru jazyka, jako je using (v jazyce C#) nebo Using (v jazyce Visual Basic), není nutné.

Datové proudy paměti vytvořené pomocí pole bez znaménka poskytují neschovatelný datový proud dat, který nelze změnit. Při použití bajtového pole nelze připojit ani zmenšit datový proud, i když můžete být schopni upravit existující obsah v závislosti na parametrech předaných do konstruktoru. Datové proudy prázdné paměti se dají měnit a dají se zapisovat do a číst z.

Pokud je objekt MemoryStream přidán do souboru ResX nebo souboru .resources, zavolejte metodu GetStream za běhu a načtěte ji.

Pokud je objekt MemoryStream serializován do souboru prostředku, bude ve skutečnosti serializován jako UnmanagedMemoryStream. Toto chování poskytuje lepší výkon a také schopnost získat ukazatel na data přímo, aniž byste museli procházet Stream metodami.

Konstruktory

MemoryStream()	Inicializuje novou instanci MemoryStream třídy s rozšiřitelnou kapacitou inicializována na nulu.
MemoryStream(Byte[])	Inicializuje novou nesložitelnou instanci třídy MemoryStream na základě zadaného pole bajtů.
MemoryStream(Byte[], Boolean)	Inicializuje novou neschovatelnou instanci třídy MemoryStream na základě zadaného pole bajtů s CanWrite vlastnost nastavenou podle zadaného.
MemoryStream(Byte[], Int32, Int32)	Inicializuje novou nesložitelnou instanci třídy MemoryStream na základě zadané oblasti (index) bajtového pole.
MemoryStream(Byte[], Int32, Int32, Boolean)	Inicializuje novou nesložitelnou instanci třídy MemoryStream na základě zadané oblasti pole bajtů s CanWrite vlastnost nastavenou podle zadané.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Inicializuje novou instanci MemoryStream třídy na základě zadané oblasti bajt pole, s CanWrite vlastnost nastavena, jak je zadána, a schopnost volat GetBuffer() nastavena podle zadaného.
MemoryStream(Int32)	Inicializuje novou instanci MemoryStream třídy s rozšiřitelnou kapacitou inicializována podle zadaného.

Vlastnosti

CanRead	Získá hodnotu určující, zda aktuální datový proud podporuje čtení.
CanSeek	Získá hodnotu určující, zda aktuální datový proud podporuje hledání.
CanTimeout	Získá hodnotu, která určuje, zda aktuální datový proud může vypršení časového limitu. (Zděděno od Stream)
CanWrite	Získá hodnotu určující, zda aktuální datový proud podporuje zápis.
Capacity	Získá nebo nastaví počet bajtů přidělených pro tento datový proud.
Length	Získá délku datového proudu v bajtech.
Position	Získá nebo nastaví aktuální pozici v rámci datového proudu.
ReadTimeout	Získá nebo nastaví hodnotu v milisekundách, která určuje, jak dlouho se datový proud pokusí přečíst před uplynutím časového limitu. (Zděděno od Stream)
WriteTimeout	Získá nebo nastaví hodnotu v milisekundách, která určuje, jak dlouho se datový proud pokusí zapsat před uplynutím časového limitu. (Zděděno od Stream)

Metody

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení. (Zvažte místo toho použití ReadAsync(Byte[], Int32, Int32, CancellationToken).)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci zápisu. (Zvažte místo toho použití WriteAsync(Byte[], Int32, Int32, CancellationToken).)
Close()	Zavře aktuální datový proud a uvolní všechny prostředky (například sokety a popisovače souborů) přidružené k aktuálnímu datovému proudu. Místo volání této metody se ujistěte, že je datový proud správně uvolněn. (Zděděno od Stream)
CopyTo(Stream)	Přečte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyTo(Stream, Int32)	Načte bajty z aktuálního datového proudu paměti a zapíše je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti.
CopyToAsync(Stream)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadaného tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronně čte všechny bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti a tokenu zrušení.
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužícího ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Přidělí objekt WaitHandle. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané Stream. (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané MemoryStream třídou a volitelně uvolní spravované prostředky.
DisposeAsync()	Asynchronně uvolní nespravované prostředky používané Stream. (Zděděno od Stream)
EndRead(IAsyncResult)	Čeká na dokončení čekajícího asynchronního čtení. (Zvažte místo toho použití ReadAsync(Byte[], Int32, Int32, CancellationToken).)
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu. (Zvažte místo toho použití WriteAsync(Byte[], Int32, Int32, CancellationToken).)
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Flush()	Přepíše metodu Flush() tak, aby nebyla provedena žádná akce.
FlushAsync()	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně vymaže všechny vyrovnávací paměti pro tento stream a monitoruje požadavky na zrušení.
GetBuffer()	Vrátí pole nepodepsaných bajtů, ze kterých byl tento datový proud vytvořen.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního objektu MarshalByRefObject. (Zděděno od MarshalByRefObject)
ObjectInvariant()	Zastaralé. Poskytuje podporu pro Contract. (Zděděno od Stream)
Read(Byte[], Int32, Int32)	Přečte blok bajtů z aktuálního datového proudu a zapíše data do vyrovnávací paměti.
Read(Span<Byte>)	Přečte posloupnost bajtů z aktuálního datového proudu paměti a posune pozici v rámci datového proudu paměti o počet přečtených bajtů.
ReadAsync(Byte[], Int32, Int32)	Asynchronně čte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně přečte posloupnost bajtů z aktuálního datového proudu, posune pozici v datovém proudu o počet přečtených bajtů a monitoruje žádosti o zrušení.
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně přečte posloupnost bajtů z aktuálního datového proudu paměti, zapíše posloupnost do destination, posune pozici v rámci datového proudu paměti o počet přečtených bajtů a monitoruje požadavky na zrušení.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Čte alespoň minimální počet bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronně čte alespoň minimální počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu o počet přečtených bajtů a monitoruje žádosti o zrušení. (Zděděno od Stream)
ReadByte()	Načte bajt z aktuálního datového proudu.
ReadExactly(Byte[], Int32, Int32)	Přečte count počet bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu. (Zděděno od Stream)
ReadExactly(Span<Byte>)	Přečte bajty z aktuálního datového proudu a posune pozici v rámci datového proudu, dokud se buffer nenaplní. (Zděděno od Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte count počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu a monitoruje požadavky na zrušení. (Zděděno od Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu, posune pozici v rámci datového proudu, dokud se buffer nenaplní, a monitoruje žádosti o zrušení. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Nastaví pozici v aktuálním datovém proudu na zadanou hodnotu.
SetLength(Int64)	Nastaví délku aktuálního datového proudu na zadanou hodnotu.
ToArray()	Zapíše obsah datového proudu do pole bajtů bez ohledu na Position vlastnost.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
TryGetBuffer(ArraySegment<Byte>)	Vrátí pole nepodepsaných bajtů, ze kterých byl tento datový proud vytvořen. Vrácená hodnota označuje, jestli byl převod úspěšný.
Write(Byte[], Int32, Int32)	Zapíše blok bajtů do aktuálního datového proudu pomocí dat načtených z vyrovnávací paměti.
Write(ReadOnlySpan<Byte>)	Zapíše posloupnost bajtů obsažených v source do aktuálního datového proudu paměti a posune aktuální pozici v rámci tohoto datového proudu paměti o počet zapsaných bajtů.
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu o počet zapsaných bajtů. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapíše posloupnost bajtů do aktuálního datového proudu, posune aktuální pozici v tomto datovém proudu o počet zapsaných bajtů a monitoruje žádosti o zrušení.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapíše posloupnost bajtů obsažených v source do aktuálního datového proudu paměti, posune aktuální pozici v rámci tohoto datového proudu paměti o počet zapsaných bajtů a monitoruje požadavky na zrušení.
WriteByte(Byte)	Zapíše bajt do aktuálního datového proudu na aktuální pozici.
WriteTo(Stream)	Zapíše celý obsah tohoto datového proudu paměti do jiného datového proudu.

Metody rozšíření

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronně čte bajty z Stream a zapisuje je do zadané PipeWriterpomocí tokenu zrušení.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, jak čekají na úlohy vrácené z asynchronního jednorázového použití.

Viz také

• soubor a streamování vstupně-výstupních
• Postupy: Čtení textu ze souboru
• Postupy: Zápis textu do souboru