MemoryStream Osztály

Definíció

Névtér:

System.IO

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

MemoryStream.cs

Létrehoz egy streamet, amelynek a háttértárolója a memória.

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

public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Öröklődés

Object

MarshalByRefObject

Stream

MemoryStream

Példák

Az alábbi példakód bemutatja, hogyan olvashat és írhat adatokat memória használatával háttértárként.

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

Megjegyzések

A stream aktuális pozíciója az a pozíció, ahol a következő olvasási vagy írási művelet végbe mehet. Az aktuális pozíció lekérhető vagy beállítható a Seek módszerrel. Új példány MemoryStream létrehozásakor az aktuális pozíció nullára van állítva.

Note

Ez a típus implementálja az interfészt IDisposable , de valójában nincs elidegenítendő erőforrása. Ez azt jelenti, hogy a Dispose() közvetlen meghívásával vagy egy olyan nyelvi szerkezettel, mint például using (C#-ban) vagy Using (Visual Basic) nem szükséges.

Az aláíratlan bájttömbökkel létrehozott memóriastreamek nem méretezhető adatfolyamot biztosítanak az adatokból. Bájttömb használata esetén nem fűzheti hozzá és nem zsugoríthatja a streamet, bár a konstruktornak átadott paraméterektől függően módosíthatja a meglévő tartalmat. Az üres memóriastreamek átméretezhetők, és írásra és olvasásra is használhatók.

Ha egy objektumot MemoryStream hozzáad egy ResX-fájlhoz vagy egy .resources-fájlhoz, hívja meg a GetStream metódust futásidőben, hogy lekérje.

Ha egy MemoryStream objektumot szerializál egy erőforrásfájlba, az valójában szerializálva UnmanagedMemoryStreamlesz. Ez a viselkedés jobb teljesítményt biztosít, valamint lehetővé teszi, hogy közvetlenül az adatokra mutató mutatót kapjon anélkül, hogy át kellene mennie Stream a metódusokon.

Konstruktorok

Name	Description
MemoryStream()	Inicializálja az MemoryStream osztály új példányát nullára inicializálható kapacitással.
MemoryStream(Byte[], Boolean)	Inicializálja az osztály új, nem átméretezhető példányát a MemoryStream megadott bájttömb alapján a CanWrite megadott tulajdonságkészlettel.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Inicializálja az MemoryStream osztály új példányát egy bájttömb megadott régiója alapján, a CanWrite megadott tulajdonsággal, valamint a megadott hívási GetBuffer() lehetőséggel.
MemoryStream(Byte[], Int32, Int32, Boolean)	Inicializálja az MemoryStream osztály új, nem átméretezhető példányát egy bájttömb megadott régiója alapján, a tulajdonság pedig a CanWrite megadott módon van beállítva.
MemoryStream(Byte[], Int32, Int32)	Inicializálja az osztály új, nem átméretezhető példányát egy MemoryStream bájttömb megadott régiója (indexe) alapján.
MemoryStream(Byte[])	Inicializálja az osztály új, nem átméretezhető példányát a MemoryStream megadott bájttömb alapján.
MemoryStream(Int32)	Inicializálja az MemoryStream osztály új példányát a megadott módon inicializált bővíthető kapacitással.

Tulajdonságok

Name	Description
CanRead	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e az olvasást.
CanSeek	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e a keresést.
CanTimeout	Olyan értéket kap, amely meghatározza, hogy az aktuális stream időtúllépést okozhat-e. (Öröklődés forrása Stream)
CanWrite	Egy értéket kap, amely jelzi, hogy az aktuális stream támogatja-e az írást.
Capacity	Lekéri vagy beállítja a streamhez lefoglalt bájtok számát.
Length	Bájtban lekéri a stream hosszát.
Position	Lekéri vagy beállítja az aktuális pozíciót a streamen belül.
ReadTimeout	Ezredmásodpercben lekéri vagy beállítja azt az értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg olvasni, mielőtt túllépi az időkorlátot. (Öröklődés forrása Stream)
WriteTimeout	Ezredmásodpercben lekéri vagy beállít egy értéket, amely meghatározza, hogy a stream mennyi ideig kísérel meg írni, mielőtt időtúllépést végezne. (Öröklődés forrása Stream)

Metódusok

Name	Description
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron olvasási műveletet kezd. (Fontolja meg a használatot ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Aszinkron írási műveletet kezd. (Fontolja meg a használatot WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
Close()	Bezárja az aktuális streamet, és felszabadítja az aktuális adatfolyamhoz társított összes erőforrást (például szoftvercsatornákat és fájlfogópontokat). A metódus meghívása helyett győződjön meg arról, hogy a stream megfelelően van elosztva. (Öröklődés forrása Stream)
CopyTo(Stream, Int32)	Beolvassa a bájtokat az aktuális memóriastreamből, és egy megadott pufferméret használatával egy másik streambe írja őket.
CopyTo(Stream)	Beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy megadott lemondási jogkivonat használatával egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Aszinkron módon beolvassa az összes bájtot az aktuális adatfolyamból, és egy megadott pufferméret és lemondási jogkivonat használatával egy másik streambe írja őket.
CopyToAsync(Stream, Int32)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, és egy megadott puffermérettel egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CopyToAsync(Stream)	Aszinkron módon beolvassa a bájtokat az aktuális streamből, és egy másik streambe írja őket. Mindkét streampozíciót a másolt bájtok száma emeli ki. (Öröklődés forrása Stream)
CreateWaitHandle()	Elavult. Objektum lefoglalása WaitHandle . (Öröklődés forrása Stream)
Dispose()	Felszabadítja a .-hez használt összes erőforrást Stream. (Öröklődés forrása Stream)
Dispose(Boolean)	Felszabadítja az osztály által MemoryStream használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
DisposeAsync()	Aszinkron módon felszabadítja a nem felügyelt erőforrásokat, amelyeket a Stream. (Öröklődés forrása Stream)
EndRead(IAsyncResult)	Megvárja, amíg a függőben lévő aszinkron olvasás befejeződik. (Fontolja meg a használatot ReadAsync(Byte[], Int32, Int32, CancellationToken) .)
EndWrite(IAsyncResult)	Aszinkron írási művelet befejezése. (Fontolja meg a használatot WriteAsync(Byte[], Int32, Int32, CancellationToken) .)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Flush()	Felülbírálja a Flush() metódust, hogy a művelet ne legyen végrehajtva.
FlushAsync()	Aszinkron módon törli az adatfolyam összes pufferét, és a pufferelt adatokat a mögöttes eszközre írja. (Öröklődés forrása Stream)
FlushAsync(CancellationToken)	Aszinkron módon törli a stream összes pufferét, és figyeli a lemondási kérelmeket.
GetBuffer()	Azoknak az aláíratlan bájtoknak a tömbét adja vissza, amelyekből a stream létre lett hozva.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Elavult. Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Elavult. Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
ObjectInvariant()	Elavult. Támogatja a Contract. (Öröklődés forrása Stream)
Read(Byte[], Int32, Int32)	Beolvassa az aktuális adatfolyam bájtblokkját, és pufferbe írja az adatokat.
Read(Span<Byte>)	Beolvassa a bájtok sorozatát az aktuális memóriastreamből, és az olvasási bájtok számával előrelépteti a memóriafolyamon belüli pozíciót.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális adatfolyamból, az olvasási bájtok számával előrelép a streamben, és figyeli a lemondási kérelmeket.
ReadAsync(Byte[], Int32, Int32)	Aszinkron módon beolvassa az aktuális adatfolyamból származó bájtok sorozatát, és az olvasási bájtok számával előrelépteti a streamen belüli pozíciót. (Öröklődés forrása Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Aszinkron módon beolvassa a bájtok sorozatát az aktuális memóriastreamből, beírja a sorozatot a memóriába destination, előrelép a memóriastreamben az olvasási bájtok számával, és figyeli a lemondási kérelmeket.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legalább egy bájtot olvas be az aktuális adatfolyamból, és az olvasási bájtok számával előrelép a streamen belül. (Öröklődés forrása Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Aszinkron módon legalább egy minimális bájtszámot olvas be az aktuális streamből, az olvasási bájtok számával előrelép a streamen belül, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
ReadByte()	Az aktuális streamből beolvassa a bájtot.
ReadExactly(Byte[], Int32, Int32)	Beolvassa a bájtok count számát az aktuális streamből, és előrelép a streamen belüli pozíción. (Öröklődés forrása Stream)
ReadExactly(Span<Byte>)	Beolvassa a bájtokat az aktuális adatfolyamból, és a streamen belüli pozíciót a feltöltésig buffer előrelépteti. (Öröklődés forrása Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon beolvassa a bájtok count számát az aktuális streamből, előrelép a streamben, és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Aszinkron módon beolvassa a bájtokat az aktuális adatfolyamból, a streamen belüli pozíciót a feltöltésig buffer , és figyeli a lemondási kérelmeket. (Öröklődés forrása Stream)
Seek(Int64, SeekOrigin)	Az aktuális adatfolyamon belüli pozíciót a megadott értékre állítja.
SetLength(Int64)	Az aktuális stream hosszát a megadott értékre állítja.
ToArray()	A stream tartalmát a tulajdonságtól függetlenül Position egy bájttömbbe írja.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
TryGetBuffer(ArraySegment<Byte>)	Azoknak az aláíratlan bájtoknak a tömbét adja vissza, amelyekből a stream létre lett hozva. A visszatérési érték azt jelzi, hogy az átalakítás sikeres volt-e.
Write(Byte[], Int32, Int32)	Bájtblokkot ír az aktuális adatfolyamba egy pufferből beolvasott adatok használatával.
Write(ReadOnlySpan<Byte>)	Az aktuális memóriafolyamban source található bájtok sorrendjét írja le, és a megírt bájtok számával előrelépteti a memóriafolyamon belüli aktuális pozíciót.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Aszinkron módon bájtok sorozatát írja az aktuális streambe, az aktuális pozíciót a streamen belül a megírt bájtok számával lépteti előre, és figyeli a lemondási kérelmeket.
WriteAsync(Byte[], Int32, Int32)	Aszinkron módon bájtok sorozatát írja az aktuális adatfolyamba, és a megírt bájtok számával előrelépteti a stream aktuális pozícióját. (Öröklődés forrása Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Aszinkron módon írja be az aktuális memóriafolyamba source tárolt bájtok sorrendjét, a megírt bájtok számával előrelépteti a memóriafolyam aktuális pozícióját, és figyeli a lemondási kérelmeket.
WriteByte(Byte)	Bájtot ír az aktuális streambe az aktuális pozícióban.
WriteTo(Stream)	A memóriastream teljes tartalmát egy másik streambe írja.

Bővítő metódusok

Name	Description
ConfigureAwait(IAsyncDisposable, Boolean)	Konfigurálja, hogy az aszinkron eldobható feladatok hogyan lesznek végrehajtva.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Aszinkron módon beolvassa a bájtokat a Stream megadottból, és egy lemondási jogkivonat használatával írja őket a megadottba PipeWriter.

Lásd még

• Fájl és folyam I/O
• Útmutató: Szöveg beolvasása fájlból
• Útmutató: Szöveg írása fájlba