(0) exportieren Drucken
Alle erweitern
1 von 3 fanden dies hilfreich - Dieses Thema bewerten.

MemoryStream-Klasse

Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.

Namespace: System.IO
Assembly: mscorlib (in mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public class MemoryStream : Stream
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public class MemoryStream extends Stream
SerializableAttribute 
ComVisibleAttribute(true) 
public class MemoryStream extends Stream

Ein Beispiel für das Erstellen einer Datei und das Schreiben von Text in eine Datei finden Sie unter Gewusst wie: Schreiben von Text in eine Datei. Ein Beispiel für das Lesen von Text aus einer Datei finden Sie unter Gewusst wie: Lesen aus einer Textdatei. Ein Beispiel für das Lesen aus einer Binärdatei und das Schreiben in eine Binärdatei finden Sie unter Gewusst wie: Lesen und Schreiben einer neu erstellten Datendatei.

Die MemoryStream-Klasse erstellt Streams, die als Sicherungsspeicher den Arbeitsspeicher anstelle eines Datenträgers oder einer Netzwerkverbindung verwenden. MemoryStream kapselt Daten, die als Array vorzeichenloser Bytes gespeichert sind, das beim Erstellen eines MemoryStream-Objekts initialisiert wird oder auch leer erstellt werden kann. Auf die gekapselten Daten kann direkt im Arbeitsspeicher zugegriffen werden. Arbeitsspeicherstreams können den Bedarf an temporären Puffern und Dateien in einer Anwendung verringern.

Die current position eines Streams ist die Position, an der der nächste Lese- oder Schreibvorgang ausgeführt werden kann. Die aktuelle Position kann abgerufen oder über die Seek-Methode festgelegt werden. Beim Erstellen einer neuen Instanz von MemoryStream ist die aktuelle Position auf 0 festgelegt.

Arbeitsspeicherstreams, die mit einem Array vorzeichenloser Bytes erstellt wurden, bieten eine in ihrer Größe unveränderbaren Streamansicht der Daten, in die lediglich geschrieben werden kann. Wenn Sie ein Bytearray verwenden, können den Stream weder verkleinern noch etwas an diesen anfügen. Sie können aber je nach den an den Konstruktor übergebenen Parametern den vorhandenen Inhalt bearbeiten. Bei leeren Arbeitsspeicherstreams ist es möglich, deren Größe zu ändern, in diese schreiben und aus diesen lesen.

Wenn ein MemoryStream-Objekt zu einer RESX-Datei oder einer RESOURCES-Datei hinzugefügt wird, rufen Sie zum Abrufen die GetStream-Methode zur Laufzeit auf.

Ein MemoryStream-Objekt wird als UnmanagedMemoryStream in eine Ressourcendatei serialisiert. Dies verbessert die Leistung und ermöglicht zudem das Abrufen eines direkten Zeigers auf die Daten, ohne die Stream-Methoden verwenden zu müssen.

Hinweis zu Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows CE: In Windows CE kann ein aus der Zwischenablage eingefügter Arbeitsspeicherstream etwas größer sein als der in die Zwischenablage kopierte Arbeitsspeicherstream, da zusätzliche Bytes am Ende des ursprünglichen Arbeitsspeicherstreams angehängt werden können. Um den Arbeitsspeicherstream exakt abzurufen und die Art und Weise des Empfangs zu bestimmen, stellen Sie dem Objekt die Größe als Präfix voran, oder kopieren Sie ein DataObject mit dem Arbeitsspeicherstream und einem Zeichenfolgenwert seiner Größe in die Zwischenablage.

Das folgende Codebeispiel veranschaulicht das Lesen und Schreiben von Daten unter Verwendung des Arbeitsspeichers als Sicherungsspeicher.

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.InvalidPathChars);

        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++] = 
                    Convert.ToByte(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);
        }
    }
}

import System.*;
import System.IO.*;
import System.Text.*;

class MemStream
{   
    public static void main(String[] args)
    {
        int count;
        ubyte byteArray[];
        char charArray[];
        UnicodeEncoding uniEncoding =  new UnicodeEncoding();

        // Create the data to write to the stream.
        ubyte firstString[] = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        ubyte secondString[] = uniEncoding.GetBytes(Path.InvalidPathChars);
        MemoryStream memStream =  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++]);
            }

            // Write the stream properties to the console.
            Console.WriteLine(
                "Capacity = {0}, Length = {1}, Position = {2}\n", 
                (new Integer( memStream.get_Capacity())).ToString(),
                (new Long ( memStream.get_Length())).ToString(),
                (new Long ( memStream.get_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 ubyte[(int)memStream.get_Length()];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte.
            while ((count < memStream.get_Length())) {
                byteArray[count++]= Convert.ToByte(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);
        }
        finally {
            memStream.Dispose();
        }
    }//main
} //MemStream

System.Object
   System.MarshalByRefObject
     System.IO.Stream
      System.IO.MemoryStream
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.