MemoryStream Classe

Riferimento

Definizione

Spazio dei nomi:: System.IO

Assembly:: System.IO.dll

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Crea un flusso il cui archivio di backup è costituito dalla memoria.

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

Ereditarietà: Object

Stream
MemoryStream

Ereditarietà: Object

MarshalByRefObject

Stream
MemoryStream

Attributi: SerializableAttribute ComVisibleAttribute

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere dati usando la memoria come archivio di backup.

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

Commenti

La posizione corrente di un flusso è la posizione in cui può essere eseguita l'operazione di lettura o scrittura successiva. La posizione corrente può essere recuperata o impostata tramite il Seek metodo . Quando viene creata una nuova istanza di MemoryStream , la posizione corrente viene impostata su zero.

Nota

Questo tipo implementa l'interfaccia IDisposable, ma attualmente non ha risorse da eliminare. Questo significa che non è necessario eliminarlo chiamando direttamente Dispose() o tramite un costrutto del linguaggio, come using (in C#) o Using (in Visual Basic).

I flussi di memoria creati con una matrice di byte senza segno forniscono un flusso non ridimensionabile dei dati. Quando si usa una matrice di byte, non è possibile accodare né compattare il flusso, anche se potrebbe essere possibile modificare il contenuto esistente in base ai parametri passati al costruttore. I flussi di memoria vuoti sono ridimensionabili e possono essere scritti e letti da.

Se un MemoryStream oggetto viene aggiunto a un file ResX o a un file con estensione resources, chiamare il GetStream metodo in fase di esecuzione per recuperarlo.

Se un MemoryStream oggetto viene serializzato in un file di risorse, verrà effettivamente serializzato come .UnmanagedMemoryStream Questo comportamento offre prestazioni migliori, nonché la possibilità di ottenere direttamente un puntatore ai dati, senza dover passare attraverso Stream i metodi.

Costruttori

MemoryStream()	Inizializza una nuova istanza della classe MemoryStream con una capacità espandibile inizializzata su zero.
MemoryStream(Byte[])	Inizializza una nuova istanza non ridimensionabile della classe MemoryStream in base alla matrice di byte specificata.
MemoryStream(Byte[], Boolean)	Inizializza una nuova istanza non ridimensionabile della classe MemoryStream in base alla matrice di byte specificata, con la proprietà CanWrite impostata secondo quanto specificato.
MemoryStream(Byte[], Int32, Int32)	Inizializza una nuova istanza non ridimensionabile della classe MemoryStream in base alla area specificata (indice) di una matrice di byte.
MemoryStream(Byte[], Int32, Int32, Boolean)	Inizializza una nuova istanza non ridimensionabile della classe MemoryStream in base all'area specificata di una matrice di byte, con la proprietà CanWrite impostata secondo quanto specificato.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Inizializza una nuova istanza della classe MemoryStream in base all'area specificata di una matrice di byte, con la proprietà CanWrite impostata secondo quanto specificato e la possibilità di chiamare il metodo GetBuffer() impostato nel modo specificato.
MemoryStream(Int32)	Inizializza una nuova istanza della classe MemoryStream con una capacità espandibile inizializzata secondo quanto specificato.

Proprietà

CanRead	Ottiene un valore che indica se il flusso corrente supporta la lettura.
CanSeek	Ottiene un valore che indica se il flusso corrente supporta la ricerca.
CanTimeout	Ottiene un valore che determina se il flusso corrente prevede il timeout. (Ereditato da Stream)
CanWrite	Ottiene un valore che indica se il flusso corrente supporta la scrittura.
Capacity	Ottiene o imposta il numero di byte allocati per questo flusso.
Length	Ottiene la lunghezza in byte del flusso.
Position	Ottiene o imposta la posizione corrente all'interno del flusso.
ReadTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. (Ereditato da Stream)
WriteTimeout	Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. (Ereditato da Stream)

Metodi

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di lettura asincrona. Si consiglia di usare ReadAsync(Byte[], Int32, Int32, CancellationToken).
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di lettura asincrona. Si consiglia di usare ReadAsync(Byte[], Int32, Int32). (Ereditato da Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32, CancellationToken).
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Inizia un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32). (Ereditato da Stream)
Close()	Chiude il flusso in lettura e scrittura.
Close()	Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente. (Ereditato da Stream)
CopyTo(Stream)	Legge i byte dal flusso corrente e li scrive in un altro flusso. (Ereditato da Stream)
CopyTo(Stream, Int32)	Legge i byte dal flusso di memoria corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.
CopyTo(Stream, Int32)	Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. (Ereditato da Stream)
CopyToAsync(Stream)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. (Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato. (Ereditato da Stream)
CopyToAsync(Stream, Int32)	Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata. (Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento.
CopyToAsync(Stream, Int32, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. (Ereditato da Stream)
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleta. Obsoleta. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate da Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate dalla classe MemoryStream e facoltativamente le risorse gestite.
Dispose(Boolean)	Rilascia le risorse non gestite usate da Stream e, facoltativamente, le risorse gestite. (Ereditato da Stream)
DisposeAsync()	Consente di liberare in modo asincrono le risorse non gestite utilizzate da Stream. (Ereditato da Stream)
EndRead(IAsyncResult)	Attende il completamento della lettura asincrona in sospeso. Si consiglia di usare ReadAsync(Byte[], Int32, Int32, CancellationToken).
EndRead(IAsyncResult)	Attende il completamento della lettura asincrona in sospeso. Si consiglia di usare ReadAsync(Byte[], Int32, Int32). (Ereditato da Stream)
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32, CancellationToken).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona. Si consiglia di usare WriteAsync(Byte[], Int32, Int32). (Ereditato da Stream)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Flush()	Esegue l'override del metodo Flush() in modo che non venga effettuata alcuna operazione.
FlushAsync()	Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento.
FlushAsync(CancellationToken)	Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. (Ereditato da Stream)
GetBuffer()	Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleta. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleta. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Questa API supporta l'infrastruttura del prodotto e non è previsto che venga usata direttamente dal codice. Fornisce supporto per un oggetto Contract.
ObjectInvariant()	Obsoleta. Fornisce supporto per un oggetto Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer.
Read(Span<Byte>)	Legge una sequenza di byte dal flusso di memoria corrente e fa avanzare la posizione corrente nel flusso di memoria del numero di byte letti.
Read(Span<Byte>)	Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32)	Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso di memoria corrente, scrive la sequenza in `destination`, fa avanzare la posizione all'interno del flusso di memoria in base al numero di byte letti e monitora le richieste di annullamento.
ReadAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadByte()	Legge un byte dal flusso corrente.
Seek(Int64, SeekOrigin)	Imposta la posizione all'interno del flusso corrente sul valore specificato.
SetLength(Int64)	Imposta la lunghezza del flusso corrente sul valore specificato.
ToArray()	Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà Position.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TryGetBuffer(ArraySegment<Byte>)	Restituisce la matrice di byte senza segno da cui è stato creato questo flusso. Il valore restituito indica se la conversione è riuscita.
Write(Byte[], Int32, Int32)	Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer.
Write(ReadOnlySpan<Byte>)	Scrive la sequenza di byte contenuti in `source` nel flusso di memoria corrente e fa avanzare la posizione corrente all'interno del flusso di memoria del numero di byte scritti.
Write(ReadOnlySpan<Byte>)	Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. (Ereditato da Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrive in modo asincrono la sequenza di byte contenuta in `source` nel flusso di memoria corrente, sposta in avanti la posizione corrente all'interno del flusso di memoria del numero di byte scritti ed esegue il monitoraggio delle richieste di annullamento.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. (Ereditato da Stream)
WriteByte(Byte)	Scrive un byte nella posizione corrente all'interno del flusso corrente.
WriteTo(Stream)	Scrive l'intero contenuto del flusso di memoria in un altro flusso.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da Stream.

(Ereditato da Stream)

Metodi di estensione

AsInputStream(Stream)	Converte un flusso gestito in .NET per app di Windows Store in un flusso di input in Windows Runtime.
AsOutputStream(Stream)	Converte un flusso gestito in .NET per app di Windows Store in un flusso di output in Windows Runtime.
AsRandomAccessStream(Stream)	Converte il flusso specificato in un flusso di accesso casuale.
GetWindowsRuntimeBuffer(MemoryStream)	Restituisce un'interfaccia Windows.Storage.Streams.IBuffer che rappresenta la stessa memoria del flusso di memoria specificato.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Restituisce un'interfaccia Windows.Storage.Streams.IBuffer che rappresenta un'area all'interno della memoria rappresentata dal flusso di memoria specificato.
ConfigureAwait(IAsyncDisposable, Boolean)	Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.

Si applica a