MemoryStream Třída

Definice

Obor názvů:

System.IO

Sestavení:

System.Runtime.dll

Zdroj:

MemoryStream.cs

Vytvoří datový proud, jehož záložním úložištěm 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ího ú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, na které může proběhnout další operace čtení nebo zápisu. Aktuální pozici lze načíst nebo nastavit pomocí Seek metody . Při vytvoření nové instance je MemoryStream aktuální pozice nastavena na nulu.

Poznámka

Tento typ implementuje IDisposable rozhraní, 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 pomocí konstruktoru jazyka, jako using je (v jazyce C#) nebo Using (v jazyce Visual Basic), není nutné.

Datové proudy paměti vytvořené pomocí pole bajtů bez znaménka poskytují datový proud dat bez změny velikosti. Při použití pole bajtů nelze připojit ani zmenšit datový proud, ačkoli 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 velikost a dají se zapisovat do datového proudu a číst z toho.

MemoryStream Pokud je objekt přidán do souboru ResX nebo souboru .resources, voláním GetStream metody za běhu jej načtěte.

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

Konstruktory

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

Vlastnosti

CanRead	Získá hodnotu označující, zda aktuální datový proud podporuje čtení.
CanSeek	Získá hodnotu označ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 označ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í číst před vypršení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í zapisovat před vypršení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 datový proud je správně odstraně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ů se posouvají podle počtu zkopírovaných bajtů. (Zděděno od Stream)
CopyTo(Stream, Int32)	Načte bajty z aktuálního paměťového streamu a zapíše je do jiného datového proudu s použitím 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ů se posouvají podle počtu zkopírovaných bajtů. (Zděděno od Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronně přečte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu pomocí zadaného tokenu zrušení. Obě pozice datových proudů se posouvají podle počtu zkopírovaných bajtů. (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ů se posouvají podle počtu zkopírovaných bajtů. (Zděděno od Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronně přečte všechny bajty z aktuálního datového proudu a zapíše 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 sloužící ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Přidělí WaitHandle objekt. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané nástrojem 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, které Streampoužívá . (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čí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Flush()	Přepíše metodu Flush() tak, aby se neprováděla žádná akce.
FlushAsync()	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a způsobí zápis všech dat do vyrovnávací paměti do základního zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a monitoruje požadavky na zrušení.
GetBuffer()	Vrátí pole bajtů bez znaménka, ze kterých byl tento datový proud vytvořen.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte aktuální životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
ObjectInvariant()	Zastaralé. Poskytuje podporu pro Contract. (Zděděno od Stream)
Read(Byte[], Int32, Int32)	Načte blok bajtů z aktuálního datového proudu a zapíše data do vyrovnávací paměti.
Read(Span<Byte>)	Nač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ě přečte posloupnost bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně přečte sekvenci 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 sleduje požadavky na zrušení.
ReadAsync(Memory<Byte>, CancellationToken)	Asynchronně přečte sekvenci bajtů z aktuálního datového proudu paměti, zapíše sekvenci 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)	Přečte alespoň minimální počet bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronně přeč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 sleduje požadavky na zrušení. (Zděděno od Stream)
ReadByte()	Načte bajt z aktuálního datového proudu.
ReadExactly(Byte[], Int32, Int32)	Nač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>)	Načte bajty z aktuálního datového proudu a posune pozici v rámci datového proudu, dokud buffer není vyplněna. (Zděděno od Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně nač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 až do buffer vyplnění 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 bajtů bez znaménka, ze kterých byl tento datový proud vytvořen. Vrácená hodnota označuje, zda převod proběhl ú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 rámci tohoto datového proudu o počet zapsaných bajtů. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně zapíše sekvenci bajtů do aktuálního datového proudu, posune aktuální pozici v rámci tohoto datového proudu o počet zapsaných bajtů a sleduje požadavky na zrušení.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapíše sekvenci bajtů obsažených v source do aktuálního paměťového streamu, 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 paměťového streamu do jiného datového proudu.

Metody rozšíření

CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronně přečte bajty z objektu Stream a zapíše je do zadaného PipeWriterobjektu pomocí tokenu zrušení.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, jak se provádí funkce awaits u úloh vrácených z asynchronního jednorázového režimu.

Viz také

• Vstupně-výstupní operace souborů a Stream
• Postupy: Čtení textu ze souboru
• Postupy: Zápis textu do souboru