MemoryStream Klass

Definition

Namnområde:

System.IO

Sammansättning:

mscorlib.dll

Skapar en ström vars lagringsplats är minne.

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

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

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

Public Class MemoryStream
Inherits Stream

Arv

Object

MarshalByRefObject

Stream

MemoryStream

Attribut

SerializableAttribute ComVisibleAttribute

Exempel

Följande kodexempel visar hur du läser och skriver data med hjälp av minne som ett lagringsplats för säkerhetskopiering.

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

Kommentarer

Den aktuella positionen för en dataström är den position där nästa läs- eller skrivåtgärd kan äga rum. Den aktuella positionen kan hämtas eller ställas in via Seek metoden. När en ny instans av MemoryStream skapas anges den aktuella positionen till noll.

Note

Den här typen implementerar IDisposable gränssnittet, men har faktiskt inga resurser att ta bort. Det innebär att det inte är nödvändigt att exponera den genom att direkt anropa Dispose() eller genom att använda en språkkonstruktion som using (i C#) eller Using (i Visual Basic).

Minnesströmmar som skapats med en osignerad bytematris ger en dataström som inte kan ändras. När du använder en bytematris kan du varken lägga till eller krympa strömmen, även om du kanske kan ändra det befintliga innehållet beroende på de parametrar som skickas till konstruktorn. Tomma minnesströmmar kan ändras och kan skrivas till och läsas från.

Om ett MemoryStream objekt läggs till i en ResX-fil eller en .resources-fil anropar GetStream du metoden vid körning för att hämta den.

Om ett MemoryStream objekt serialiseras till en resursfil serialiseras det faktiskt som en UnmanagedMemoryStream. Det här beteendet ger bättre prestanda, samt möjligheten att få en pekare till data direkt, utan att behöva gå igenom Stream metoder.

Konstruktorer

Name	Description
MemoryStream()	Initierar en ny instans av MemoryStream klassen med en utökningsbar kapacitet initierad till noll.
MemoryStream(Byte[], Boolean)	Initierar en ny icke-storleksanpassad instans av MemoryStream klassen baserat på den angivna bytematrisen med egenskapen CanWrite angiven.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Initierar en ny instans av MemoryStream klassen baserat på den angivna regionen för en bytematris, med egenskapen CanWrite angiven och möjligheten att anropa GetBuffer() angiven.
MemoryStream(Byte[], Int32, Int32, Boolean)	Initierar en ny icke-storleksanpassad instans av MemoryStream klassen baserat på den angivna regionen för en bytematris, med egenskapen CanWrite angiven.
MemoryStream(Byte[], Int32, Int32)	Initierar en ny icke-storleksanpassad instans av MemoryStream klassen baserat på den angivna regionen (index) för en bytematris.
MemoryStream(Byte[])	Initierar en ny icke-storleksanpassad instans av MemoryStream klassen baserat på den angivna bytematrisen.
MemoryStream(Int32)	Initierar en ny instans av MemoryStream klassen med en utökningsbar kapacitet initierad enligt angiven.

Egenskaper

Name	Description
CanRead	Hämtar ett värde som anger om den aktuella strömmen stöder läsning.
CanSeek	Hämtar ett värde som anger om den aktuella strömmen stöder sökning.
CanTimeout	Hämtar ett värde som avgör om den aktuella strömmen kan överskrida tidsgränsen. (Ärvd från Stream)
CanWrite	Hämtar ett värde som anger om den aktuella strömmen stöder skrivning.
Capacity	Hämtar eller anger antalet byte som allokerats för den här strömmen.
Length	Hämtar strömmens längd i byte.
Position	Hämtar eller anger den aktuella positionen i strömmen.
ReadTimeout	Hämtar eller anger ett värde i millisekunder som avgör hur länge strömmen ska försöka läsa innan tidsgränsen nås. (Ärvd från Stream)
WriteTimeout	Hämtar eller anger ett värde i millisekunder som avgör hur länge strömmen ska försöka skriva innan tidsgränsen nås. (Ärvd från Stream)

Metoder

Name	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Påbörjar en asynkron läsåtgärd. (Överväg att använda ReadAsync(Byte[], Int32, Int32) i stället.) (Ärvd från Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Påbörjar en asynkron skrivåtgärd. (Överväg att använda WriteAsync(Byte[], Int32, Int32) i stället.) (Ärvd från Stream)
Close()	Stänger den aktuella strömmen och släpper alla resurser (till exempel socketar och filhandtag) som är associerade med den aktuella strömmen. I stället för att anropa den här metoden kontrollerar du att dataströmmen tas bort korrekt. (Ärvd från Stream)
CopyTo(Stream, Int32)	Läser byteen från den aktuella strömmen och skriver dem till en annan ström med en angiven buffertstorlek. Båda strömmarnas positioner avanceras av antalet kopierade byte. (Ärvd från Stream)
CopyTo(Stream)	Läser byteen från den aktuella strömmen och skriver dem till en annan ström. Båda strömmarnas positioner avanceras av antalet kopierade byte. (Ärvd från Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Läser asynkront alla byte från den aktuella strömmen och skriver dem till en annan ström med en angiven buffertstorlek och en annulleringstoken.
CopyToAsync(Stream, Int32)	Läser asynkront byte från den aktuella strömmen och skriver dem till en annan ström med en angiven buffertstorlek. Båda strömmarnas positioner avanceras av antalet kopierade byte. (Ärvd från Stream)
CopyToAsync(Stream)	Läser asynkront byte från den aktuella strömmen och skriver dem till en annan ström. Båda strömmarnas positioner avanceras av antalet kopierade byte. (Ärvd från Stream)
CreateObjRef(Type)	Skapar ett objekt som innehåller all relevant information som krävs för att generera en proxy som används för att kommunicera med ett fjärrobjekt. (Ärvd från MarshalByRefObject)
CreateWaitHandle()	Föråldrad. Allokerar ett WaitHandle objekt. (Ärvd från Stream)
Dispose()	Släpper alla resurser som används av Stream. (Ärvd från Stream)
Dispose(Boolean)	Släpper de ohanterade resurser som används av MemoryStream klassen och släpper eventuellt de hanterade resurserna.
EndRead(IAsyncResult)	Väntar på att den väntande asynkrona läsningen ska slutföras. (Överväg att använda ReadAsync(Byte[], Int32, Int32) i stället.) (Ärvd från Stream)
EndWrite(IAsyncResult)	Avslutar en asynkron skrivåtgärd. (Överväg att använda WriteAsync(Byte[], Int32, Int32) i stället.) (Ärvd från Stream)
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
Flush()	Åsidosätter Flush() metoden så att ingen åtgärd utförs.
FlushAsync()	Rensar asynkront alla buffertar för den här strömmen och gör att buffrade data skrivs till den underliggande enheten. (Ärvd från Stream)
FlushAsync(CancellationToken)	Rensar asynkront alla buffertar för den här strömmen och övervakar begäranden om annullering.
GetBuffer()	Returnerar matrisen med osignerade byte som strömmen skapades från.
GetHashCode()	Fungerar som standard-hash-funktion. (Ärvd från Object)
GetLifetimeService()	Hämtar det aktuella livslängdstjänstobjektet som styr livslängdsprincipen för den här instansen. (Ärvd från MarshalByRefObject)
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
InitializeLifetimeService()	Hämtar ett tjänstobjekt för livslängd för att styra livslängdsprincipen för den här instansen. (Ärvd från MarshalByRefObject)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
MemberwiseClone(Boolean)	Skapar en ytlig kopia av det aktuella MarshalByRefObject objektet. (Ärvd från MarshalByRefObject)
ObjectInvariant()	Föråldrad. Tillhandahåller stöd för en Contract. (Ärvd från Stream)
Read(Byte[], Int32, Int32)	Läser ett byteblock från den aktuella strömmen och skriver data till en buffert.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Läser asynkront en sekvens med byte från den aktuella strömmen, avancerar positionen i strömmen med antalet lästa byte och övervakar begäranden om annullering.
ReadAsync(Byte[], Int32, Int32)	Läser asynkront en sekvens med byte från den aktuella strömmen och avancerar positionen i strömmen med antalet lästa byte. (Ärvd från Stream)
ReadByte()	Läser en byte från den aktuella strömmen.
Seek(Int64, SeekOrigin)	Anger positionen i den aktuella strömmen till det angivna värdet.
SetLength(Int64)	Anger längden på den aktuella strömmen till det angivna värdet.
ToArray()	Skriver dataströminnehållet till en bytematris, oavsett Position egenskap.
ToString()	Returnerar en sträng som representerar det aktuella objektet. (Ärvd från Object)
TryGetBuffer(ArraySegment<Byte>)	Returnerar matrisen med osignerade byte som strömmen skapades från. Returvärdet anger om konverteringen lyckades.
Write(Byte[], Int32, Int32)	Skriver ett block med byte till den aktuella strömmen med data som lästs från en buffert.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Skriver asynkront en sekvens med byte till den aktuella strömmen, avancerar den aktuella positionen i den här strömmen med antalet skrivna byte och övervakar begäranden om annullering.
WriteAsync(Byte[], Int32, Int32)	Skriver asynkront en sekvens med byte till den aktuella strömmen och avancerar den aktuella positionen i den här strömmen med antalet skrivna byte. (Ärvd från Stream)
WriteByte(Byte)	Skriver en byte till den aktuella strömmen på den aktuella positionen.
WriteTo(Stream)	Skriver hela innehållet i den här minnesströmmen till en annan ström.

Se även

• Fil- och ström-I/O
• Anvisningar: Läsa text från en fil
• Anvisningar: Skriva text till en fil