MemoryStream Klasse

Definition

Namespace:

System.IO

Assembly:

System.Runtime.dll

Quelle:

MemoryStream.cs

Erstellt einen Datenstrom, dessen Sicherungsspeicher Arbeitsspeicher ist.

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

public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Vererbung

Object

MarshalByRefObject

Stream

MemoryStream

Beispiele

Das folgende Codebeispiel zeigt, wie Daten mithilfe des Speichers als Sicherungsspeicher gelesen und geschrieben werden.

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

Hinweise

Die aktuelle Position eines Datenstroms ist die Position, an der der nächste Lese- oder Schreibvorgang ausgeführt werden kann. Die aktuelle Position kann über die Seek-Methode abgerufen oder festgelegt werden. Wenn eine neue Instanz von MemoryStream erstellt wird, wird die aktuelle Position auf Null festgelegt.

Anmerkung

Dieser Typ implementiert die IDisposable-Schnittstelle, verfügt jedoch nicht über Ressourcen zum Löschen. Dies bedeutet, dass das Löschen durch direktes Aufrufen von Dispose() oder durch Verwenden eines Sprachkonstrukts wie using (in C#) oder Using (in Visual Basic) nicht erforderlich ist.

Speicherstreams, die mit einem nicht signierten Bytearray erstellt wurden, stellen einen nicht verkleinerbaren Datenstrom bereit. Bei Verwendung eines Bytearrays können Sie den Datenstrom weder anfügen noch verkleinern, obwohl Sie möglicherweise die vorhandenen Inhalte je nach den Parametern ändern können, die an den Konstruktor übergeben werden. Leere Speicherdatenströme können in die Größe geändert werden und können in die Datei geschrieben und gelesen werden.

Wenn ein MemoryStream-Objekt einer ResX-Datei oder einer RESSOURCENdatei hinzugefügt wird, rufen Sie die GetStream Methode zur Laufzeit auf, um es abzurufen.

Wenn ein MemoryStream-Objekt in eine Ressourcendatei serialisiert wird, wird es tatsächlich als UnmanagedMemoryStreamserialisiert. Dieses Verhalten bietet eine bessere Leistung sowie die Möglichkeit, einen Zeiger direkt auf die Daten zu übertragen, ohne Stream Methoden durchlaufen zu müssen.

Konstruktoren

MemoryStream()	Initialisiert eine neue Instanz der MemoryStream Klasse mit einer erweiterbaren Kapazität, die auf Null initialisiert wurde.
MemoryStream(Byte[])	Initialisiert eine neue nicht verkleinerbare Instanz der MemoryStream Klasse basierend auf dem angegebenen Bytearray.
MemoryStream(Byte[], Boolean)	Initialisiert eine neue, nicht verkleinerbare Instanz der MemoryStream Klasse basierend auf dem angegebenen Bytearray, wobei die CanWrite Eigenschaft wie angegeben festgelegt ist.
MemoryStream(Byte[], Int32, Int32)	Initialisiert eine neue nicht verkleinerbare Instanz der MemoryStream Klasse basierend auf dem angegebenen Bereich (Index) eines Bytearrays.
MemoryStream(Byte[], Int32, Int32, Boolean)	Initialisiert eine neue, nicht verkleinerbare Instanz der MemoryStream Klasse basierend auf dem angegebenen Bereich eines Bytearrays, wobei die CanWrite Eigenschaft wie angegeben festgelegt ist.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Initialisiert eine neue Instanz der MemoryStream-Klasse basierend auf dem angegebenen Bereich eines Bytearrays, wobei die CanWrite -Eigenschaft wie angegeben festgelegt und die Möglichkeit zum Aufrufen GetBuffer() wie angegeben festgelegt wird.
MemoryStream(Int32)	Initialisiert eine neue Instanz der MemoryStream Klasse mit einer erweiterbaren Kapazität, die wie angegeben initialisiert wird.

Eigenschaften

CanRead	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom das Lesen unterstützt.
CanSeek	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom die Suche unterstützt.
CanTimeout	Ruft einen Wert ab, der bestimmt, ob der aktuelle Datenstrom Timeout ausführen kann. (Geerbt von Stream)
CanWrite	Ruft einen Wert ab, der angibt, ob der aktuelle Datenstrom das Schreiben unterstützt.
Capacity	Ruft die Anzahl der für diesen Datenstrom zugeordneten Bytes ab oder legt sie fest.
Length	Ruft die Länge des Datenstroms in Bytes ab.
Position	Ruft die aktuelle Position innerhalb des Datenstroms ab oder legt sie fest.
ReadTimeout	Dient zum Abrufen oder Festlegen eines Werts in Millisekunden, der bestimmt, wie lange der Datenstrom vor dem Timeout zu lesen versucht. (Geerbt von Stream)
WriteTimeout	Dient zum Abrufen oder Festlegen eines Werts in Millisekunden, der bestimmt, wie lange der Datenstrom versucht, vor dem Timeout zu schreiben. (Geerbt von Stream)

Methoden

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Startet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).)
Close()	Schließt den aktuellen Datenstrom und gibt alle Ressourcen (z. B. Sockets und Dateihandles) frei, die dem aktuellen Datenstrom zugeordnet sind. Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Datenstrom ordnungsgemäß verworfen ist. (Geerbt von Stream)
CopyTo(Stream)	Liest die Bytes aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyTo(Stream, Int32)	Liest die Bytes aus dem aktuellen Speicherdatenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom.
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe eines angegebenen Abbruchtokens in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32)	Liest die Bytes asynchron aus dem aktuellen Datenstrom und schreibt sie mithilfe einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden um die Anzahl der kopierten Bytes erweitert. (Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Liest asynchron alle Bytes aus dem aktuellen Datenstrom und schreibt sie mithilfe eines angegebenen Puffergrößen- und Abbruchtokens in einen anderen Datenstrom.
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Weist ein WaitHandle-Objekt zu. (Geerbt von Stream)
Dispose()	Gibt alle vom Streamverwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die nicht verwalteten Ressourcen frei, die von der MemoryStream Klasse verwendet werden, und gibt optional die verwalteten Ressourcen frei.
DisposeAsync()	Gibt asynchron die nicht verwalteten Ressourcen frei, die vom Streamverwendet werden. (Geerbt von Stream)
EndRead(IAsyncResult)	Wartet auf den Abschluss des ausstehenden asynchronen Lesevorgangs. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).)
EndWrite(IAsyncResult)	Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
Flush()	Überschreibt die Flush()-Methode, sodass keine Aktion ausgeführt wird.
FlushAsync()	Löscht asynchron alle Puffer für diesen Datenstrom und bewirkt, dass alle gepufferten Daten auf das zugrunde liegende Gerät geschrieben werden. (Geerbt von Stream)
FlushAsync(CancellationToken)	Löscht asynchron alle Puffer für diesen Datenstrom und überwacht Abbruchanforderungen.
GetBuffer()	Gibt das Array von nicht signierten Bytes zurück, aus denen dieser Datenstrom erstellt wurde.
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ObjectInvariant()	Veraltet. Bietet Unterstützung für eine Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest einen Byteblock aus dem aktuellen Datenstrom und schreibt die Daten in einen Puffer.
Read(Span<Byte>)	Liest eine Abfolge von Bytes aus dem aktuellen Speicherdatenstrom und wechselt die Position innerhalb des Speicherstroms um die Anzahl der gelesenen Bytes.
ReadAsync(Byte[], Int32, Int32)	Liest asynchron eine Abfolge von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest asynchron eine Abfolge von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen.
ReadAsync(Memory<Byte>, CancellationToken)	Liest asynchron eine Bytesequenz aus dem aktuellen Speicherdatenstrom, schreibt die Sequenz in destination, wechselt die Position innerhalb des Speicherstroms um die Anzahl der Gelesenen bytes und überwacht Abbruchanforderungen.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Liest mindestens eine Minimale Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Liest asynchron mindestens eine Mindestanzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus dem aktuellen Datenstrom.
ReadExactly(Byte[], Int32, Int32)	Liest count Anzahl von Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms. (Geerbt von Stream)
ReadExactly(Span<Byte>)	Liest Bytes aus dem aktuellen Datenstrom und wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist. (Geerbt von Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Liest asynchron count Anzahl von Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms und überwacht Abbruchanforderungen. (Geerbt von Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Liest asynchron Bytes aus dem aktuellen Datenstrom, wechselt die Position innerhalb des Datenstroms, bis die buffer gefüllt ist, und überwacht Abbruchanforderungen. (Geerbt von Stream)
Seek(Int64, SeekOrigin)	Legt die Position innerhalb des aktuellen Datenstroms auf den angegebenen Wert fest.
SetLength(Int64)	Legt die Länge des aktuellen Datenstroms auf den angegebenen Wert fest.
ToArray()	Schreibt den Datenstrominhalt unabhängig von der eigenschaft Position in ein Bytearray.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryGetBuffer(ArraySegment<Byte>)	Gibt das Array von nicht signierten Bytes zurück, aus denen dieser Datenstrom erstellt wurde. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich war.
Write(Byte[], Int32, Int32)	Schreibt einen Byteblock mithilfe von Daten aus einem Puffer in den aktuellen Datenstrom.
Write(ReadOnlySpan<Byte>)	Schreibt die Sequenz von Bytes, die in source enthalten sind, in den aktuellen Speicherdatenstrom und wechselt die aktuelle Position innerhalb dieses Speicherdatenstroms um die Anzahl der geschriebenen Bytes.
WriteAsync(Byte[], Int32, Int32)	Schreibt asynchron eine Bytesequenz in den aktuellen Datenstrom und wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt asynchron eine Bytesequenz in den aktuellen Datenstrom, wechselt die aktuelle Position innerhalb dieses Datenstroms um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt asynchron die Sequenz von Bytes, die in source enthalten sind, in den aktuellen Speicherdatenstrom, wechselt die aktuelle Position innerhalb dieses Speicherdatenstroms um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.
WriteByte(Byte)	Schreibt ein Byte in den aktuellen Datenstrom an der aktuellen Position.
WriteTo(Stream)	Schreibt den gesamten Inhalt dieses Speicherdatenstroms in einen anderen Datenstrom.

Erweiterungsmethoden

CopyToAsync(Stream, PipeWriter, CancellationToken)	Liest die Bytes asynchron aus dem Stream und schreibt sie mithilfe eines Abbruchtokens in das angegebene PipeWriter.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguriert, wie auf die von einem asynchronen Einweg zurückgegebenen Aufgaben gewartet wird.

Weitere Informationen

• Datei- und Stream-E/A-
• How to: Read Text from a File
• How to: Write Text to a File