MemoryStream Třída

Definice

Obor názvů:

System.IO

Sestavení:

System.IO.dll

Sestavení:

System.Runtime.dll

Sestavení:

System.Runtime.Extensions.dll

Sestavení:

mscorlib.dll

Sestavení:

netstandard.dll

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

[System.Serializable]
public class MemoryStream : System.IO.Stream

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

[<System.Serializable>]
type MemoryStream = class
    inherit Stream

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Dědičnost

Object

Stream

MemoryStream

Dědičnost

Object

MarshalByRefObject

Stream

MemoryStream

Atributy

SerializableAttribute ComVisibleAttribute

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í Seek metody. Při vytvoření nové instance MemoryStream je aktuální pozice nastavená na nulu.

Poznámka

Tento typ implementuje rozhraní, ale ve skutečnosti IDisposable nemá žádné prostředky k uvolnění. To znamená, že jeho vystavení přímého volání nebo pomocí jazykového konstruktoru, jako Dispose() using je (v jazyce C#) Using nebo (v Visual Basic), není nezbytné.

Datové proudy paměti vytvořené s nepodepsaným bajtovým polem poskytují nepřezpůsobitelný datový proud dat. Při použití bajtového pole nemůžete připojit ani zmenšit datový proud, i když můžete existující obsah upravit v závislosti na parametrech předaných do konstruktoru. Prázdné datové proudy paměti se dají změnit a dají se zapisovat a číst z.

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

MemoryStream Pokud je objekt 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 metody.

Konstruktory

MemoryStream()	Inicializuje novou instanci MemoryStream třídy s rozšiřitelnou kapacitou inicializována na nulu.
MemoryStream(Byte[])	Inicializuje novou nerizovatelnou instanci MemoryStream třídy na základě zadaného bajtového pole.
MemoryStream(Byte[], Boolean)	Inicializuje novou nepřezpůsobitelnou instanci MemoryStream třídy na základě zadaného bajtového pole se CanWrite sadou vlastností, jak je zadáno.
MemoryStream(Byte[], Int32, Int32)	Inicializuje novou nerizovatelnou instanci MemoryStream třídy na základě zadané oblasti (indexu) bajtového pole.
MemoryStream(Byte[], Int32, Int32, Boolean)	Inicializuje novou nepřezpůsobitelnou instanci MemoryStream třídy na základě zadané oblasti bajtového pole se CanWrite sadou vlastností, jak je uvedeno.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Inicializuje novou instanci MemoryStream třídy na základě zadané oblasti bajtového pole, s CanWrite vlastnost nastavenou podle zadané a schopnost volat GetBuffer() sadu 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 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 časový limit. (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 streamu 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 časovým limitem. (Zděděno od Stream)
WriteTimeout	Získá nebo nastaví hodnotu v milisekundách, která určuje, jak dlouho se datový proud před vypršením časového limitu pokusí zapisovat. (Zděděno od Stream)

Metody

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení. (Zvažte raději použití ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení. (Zvažte místo toho ReadAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci zápisu. (Zvažte raději použití WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci zápisu. (Zvažte místo toho WriteAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
Close()	Zavře stream pro čtení a zápis.
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ě 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. (Zděděno od Stream)
CopyTo(Stream, Int32)	Přeč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.
CopyTo(Stream, Int32)	Přečte 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. (Zděděno od Stream)
CopyToAsync(Stream)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu. (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í. (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. (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í.
CopyToAsync(Stream, Int32, CancellationToken)	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 a tokenu zrušení. (Zděděno od Stream)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Zastaralé. Přidělí WaitHandle objekt . (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané v Stream . (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané MemoryStream třídou a volitelně uvolní spravované prostředky.
Dispose(Boolean)	Uvolní nespravované prostředky používané objektem a Stream volitelně uvolní spravované prostředky. (Zděděno od Stream)
DisposeAsync()	Asynchronně uvolní nespravované prostředky používané objektem Stream . (Zděděno od Stream)
EndRead(IAsyncResult)	Čeká na dokončení čekajícího asynchronního čtení. (Zvažte raději použití ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
EndRead(IAsyncResult)	Čeká na dokončení čekajícího asynchronního čtení. (Zvažte místo toho ReadAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu. (Zvažte raději použití WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu. (Zvažte místo toho WriteAsync(Byte[], Int32, Int32) použití .) (Zděděno od Stream)
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 ve 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 stream a monitoruje žádosti o zrušení.
FlushAsync(CancellationToken)	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud, způsobí zápis všech dat ve vyrovnávací paměti do základního zařízení a monitoruje žádosti o zrušení. (Zděděno od Stream)
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 aktuální objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Type Získá aktuální instanci. (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ří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří kopii aktuálního objektu bez MarshalByRefObject podmět. (Zděděno od MarshalByRefObject)
ObjectInvariant()	Toto rozhraní API podporuje produktovou infrastrukturu a není určené k použití přímo z uživatelského kódu. Poskytuje podporu pro Contract.
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 počtem bajtů přečtených.
Read(Span<Byte>)	Při přepsání v odvozené třídě přečte sekvence 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)	Asynchronně přečte sekvenci 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 posloupnost 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í.
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 monitoruje požadavky zrušení. (Zděděno od Stream)
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 bajtů přečtených a monitoruje požadavky na zrušení.
ReadAsync(Memory<Byte>, 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 monitoruje požadavky zrušení. (Zděděno od Stream)
ReadByte()	Přečte bajt z aktuálního datového proudu.
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 bez znaménka bajtů, 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 do source 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ů.
Write(ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě zapíše sekvenci bajtů do aktuálního datového proudu a posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše sekvenci bajtů do aktuálního datového proudu a posune aktuální pozici v rámci tohoto datového proudu o počet zapsané bajty. (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 rámci tohoto streamu o počet zapsaných bajtů a monitoruje žádosti o zrušení.
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é bajty a monitoruje požadavky zrušení. (Zděděno od Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Asynchronně zapisuje posloupnost bajtů obsažených do source 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í.
WriteAsync(ReadOnlyMemory<Byte>, 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é bajty a monitoruje požadavky zrušení. (Zděděno od Stream)
WriteByte(Byte)	Zapíše bajt do aktuálního streamu na aktuální pozici.
WriteTo(Stream)	Zapíše celý obsah tohoto datového proudu paměti do jiného datového proudu.

Explicitní implementace rozhraní

IDisposable.Dispose()

Uvolní všechny prostředky používané v Stream . (Zděděno od Stream)

Metody rozšíření

AsInputStream(Stream)	Převede spravovaný datový proud v .NET pro aplikace Windows Store na vstupní datový proud v prostředí Windows Runtime.
AsOutputStream(Stream)	Převede spravovaný datový proud v .NET pro aplikace Windows Store na výstupní datový proud v prostředí Windows Runtime.
AsRandomAccessStream(Stream)	Převede zadaný datový proud na datový proud s náhodným přístupem.
GetWindowsRuntimeBuffer(MemoryStream)	Vrátí rozhraní Windows. Storage. Streams. IBuffer, které představuje stejnou paměť jako zadaný paměťový proud.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Vrátí rozhraní Windows. Storage. Streams. IBuffer, které představuje oblast v paměti, kterou představuje zadaný paměťový proud.
ConfigureAwait(IAsyncDisposable, Boolean)	Nakonfiguruje, jak se čekají na úlohy vrácené z asynchronního jednorázového provedení.

Viz také

• I/O souborů a proudů
• Postupy: Čtení textu ze souboru
• Postupy: Zápis textu do souboru