共用方式為


MemoryStream 類別

定義

建立備份存放區為記憶體的數據流。

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
繼承
MemoryStream
繼承
屬性

範例

下列程式代碼範例示範如何使用記憶體作為備份存放區來讀取和寫入數據。

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

備註

數據流的目前位置是下一個讀取或寫入作業可能發生的位置。 您可以透過 Seek 方法擷取或設定目前的位置。 建立 MemoryStream 的新實例時,目前的位置會設定為零。

注意

此類型會實作 IDisposable 介面,但實際上沒有任何要處置的資源。 這表示不需要直接呼叫 Dispose() 或使用語言建構,例如 using(C#) 或 Using (在 Visual Basic 中) 來處置它。

使用未簽署位元組陣列所建立的記憶體數據流會提供無法重設大小的數據流。 使用位元組陣列時,您無法附加至 或壓縮數據流,不過您可以根據傳入建構函式的參數來修改現有的內容。 空的記憶體數據流可重設大小,而且可以寫入和讀取。

如果 MemoryStream 物件新增至 ResX 檔案或 .resources 檔案,請在運行時間呼叫 GetStream 方法來擷取它。

如果 MemoryStream 物件串行化為資源檔案,則實際上會串行化為 UnmanagedMemoryStream。 此行為可提供更佳的效能,以及直接取得數據指標的能力,而不需要經過 Stream 方法。

建構函式

MemoryStream()

使用可擴充容量初始化為零,初始化 MemoryStream 類別的新實例。

MemoryStream(Byte[])

根據指定的位元組陣列,初始化 MemoryStream 類別的新不可重設大小實例。

MemoryStream(Byte[], Boolean)

根據指定的位元組陣列,初始化 MemoryStream 類別的新不可重設大小實例,並將 CanWrite 屬性設定為指定。

MemoryStream(Byte[], Int32, Int32)

根據位元組數位的指定區域(index),初始化 MemoryStream 類別的新不可重設大小實例。

MemoryStream(Byte[], Int32, Int32, Boolean)

根據位元組陣列的指定區域,初始化 MemoryStream 類別的新不可重設大小實例,並將 CanWrite 屬性設定為指定。

MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)

根據位元組陣列的指定區域,初始化 MemoryStream 類別的新實例,並將 CanWrite 屬性設定為指定,以及呼叫 GetBuffer() 設定為指定的功能。

MemoryStream(Int32)

使用已指定初始化的可擴充容量,初始化 MemoryStream 類別的新實例。

屬性

CanRead

取得值,指出目前數據流是否支援讀取。

CanSeek

取得值,指出目前數據流是否支持搜尋。

CanTimeout

取得值,這個值會判斷目前的數據流是否可以逾時。

(繼承來源 Stream)
CanWrite

取得值,指出目前數據流是否支援寫入。

Capacity

取得或設定配置給這個數據流的位元元組數目。

Length

取得以位元組為單位的數據流長度。

Position

取得或設定數據流中的目前位置。

ReadTimeout

取得或設定值,以毫秒為單位,決定數據流在逾時之前嘗試讀取的時間長度。

(繼承來源 Stream)
WriteTimeout

取得或設定值,以毫秒為單位,決定數據流在逾時之前嘗試寫入的時間長度。

(繼承來源 Stream)

方法

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

開始異步讀取作業。 (請考慮改用 ReadAsync(Byte[], Int32, Int32, CancellationToken)

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

開始異步讀取作業。 (請考慮改用 ReadAsync(Byte[], Int32, Int32)

(繼承來源 Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

開始異步寫入作業。 (請考慮改用 WriteAsync(Byte[], Int32, Int32, CancellationToken)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

開始異步寫入作業。 (請考慮改用 WriteAsync(Byte[], Int32, Int32)

(繼承來源 Stream)
Close()

關閉數據流以供讀取和寫入。

Close()

關閉目前的數據流,並釋放與目前數據流相關聯的任何資源(例如套接字和檔句柄)。 請確定已正確處置數據流,而不是呼叫此方法。

(繼承來源 Stream)
CopyTo(Stream)

從目前的數據流讀取位元組,並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CopyTo(Stream, Int32)

從目前的記憶體數據流讀取位元組,並使用指定的緩衝區大小將它們寫入另一個數據流。

CopyTo(Stream, Int32)

從目前的數據流讀取位元組,並使用指定的緩衝區大小將它們寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CopyToAsync(Stream)

以異步方式從目前的數據流讀取位元組,並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CopyToAsync(Stream, CancellationToken)

使用指定的取消標記,以異步方式從目前數據流讀取位元組,並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CopyToAsync(Stream, Int32)

使用指定的緩衝區大小,以異步方式從目前數據流讀取位元組,並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CopyToAsync(Stream, Int32, CancellationToken)

使用指定的緩衝區大小和取消標記,以異步方式從目前數據流讀取所有位元組,並將其寫入另一個數據流。

CopyToAsync(Stream, Int32, CancellationToken)

使用指定的緩衝區大小和取消標記,以異步方式從目前數據流讀取位元組,並將其寫入另一個數據流。 這兩個數據流位置都會依複製的位元元組數目進階。

(繼承來源 Stream)
CreateObjRef(Type)

建立物件,其中包含產生用來與遠端物件通訊之 Proxy 所需的所有相關信息。

(繼承來源 MarshalByRefObject)
CreateWaitHandle()
已淘汰.
已淘汰.
已淘汰.

配置 WaitHandle 物件。

(繼承來源 Stream)
Dispose()

釋放 Stream所使用的所有資源。

(繼承來源 Stream)
Dispose(Boolean)

釋放 MemoryStream 類別所使用的 Unmanaged 資源,並選擇性地釋放 Managed 資源。

Dispose(Boolean)

釋放 Stream 所使用的 Unmanaged 資源,並選擇性地釋放 Managed 資源。

(繼承來源 Stream)
DisposeAsync()

以異步方式釋放 Stream所使用的 Unmanaged 資源。

(繼承來源 Stream)
EndRead(IAsyncResult)

等候暫止的異步讀取完成。 (請考慮改用 ReadAsync(Byte[], Int32, Int32, CancellationToken)

EndRead(IAsyncResult)

等候暫止的異步讀取完成。 (請考慮改用 ReadAsync(Byte[], Int32, Int32)

(繼承來源 Stream)
EndWrite(IAsyncResult)

結束異步寫入作業。 (請考慮改用 WriteAsync(Byte[], Int32, Int32, CancellationToken)

EndWrite(IAsyncResult)

結束異步寫入作業。 (請考慮改用 WriteAsync(Byte[], Int32, Int32)

(繼承來源 Stream)
Equals(Object)

判斷指定的物件是否等於目前的物件。

(繼承來源 Object)
Flush()

覆寫 Flush() 方法,因此不會執行任何動作。

FlushAsync()

以異步方式清除此數據流的所有緩衝區,並導致任何緩衝的數據寫入基礎裝置。

(繼承來源 Stream)
FlushAsync(CancellationToken)

以異步方式清除此數據流的所有緩衝區,並監視取消要求。

FlushAsync(CancellationToken)

以異步方式清除此數據流的所有緩衝區、導致任何緩衝的數據寫入基礎裝置,並監視取消要求。

(繼承來源 Stream)
GetBuffer()

傳回建立此數據流的未帶正負號位元組陣列。

GetHashCode()

做為預設哈希函式。

(繼承來源 Object)
GetLifetimeService()
已淘汰.

擷取控制這個實例存留期原則的目前存留期服務物件。

(繼承來源 MarshalByRefObject)
GetType()

取得目前實例的 Type

(繼承來源 Object)
InitializeLifetimeService()
已淘汰.

取得存留期服務物件,以控制這個實例的存留期原則。

(繼承來源 MarshalByRefObject)
MemberwiseClone()

建立目前 Object的淺層複本。

(繼承來源 Object)
MemberwiseClone(Boolean)

建立目前 MarshalByRefObject 對象的淺層複本。

(繼承來源 MarshalByRefObject)
ObjectInvariant()

此 API 支援此產品基礎結構,但無法直接用於程式碼之中。

提供 Contract的支援。

ObjectInvariant()
已淘汰.

提供 Contract的支援。

(繼承來源 Stream)
Read(Byte[], Int32, Int32)

從目前的數據流讀取位元組區塊,並將數據寫入緩衝區。

Read(Span<Byte>)

從目前的記憶體數據流讀取位元組序列,並依讀取的位元元組數目將記憶體數據流中的位置往前移。

Read(Span<Byte>)

在衍生類別中覆寫時,從目前數據流讀取位元組序列,並將數據流中的位置依讀取的位元組數目往前移。

(繼承來源 Stream)
ReadAsync(Byte[], Int32, Int32)

以異步方式從目前數據流讀取位元組序列,並依讀取的位元元組數目將數據流中的位置往前移。

(繼承來源 Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

以異步方式從目前數據流讀取位元組序列、依讀取的位元元組數目將數據流中的位置往前移,並監視取消要求。

ReadAsync(Byte[], Int32, Int32, CancellationToken)

以異步方式從目前數據流讀取位元組序列、依讀取的位元元組數目將數據流中的位置往前移,並監視取消要求。

(繼承來源 Stream)
ReadAsync(Memory<Byte>, CancellationToken)

以異步方式從目前的記憶體數據流讀取位元組序列、將序列寫入 destination、將記憶體數據流中的位置依讀取的位元組數目往前移,並監視取消要求。

ReadAsync(Memory<Byte>, CancellationToken)

以異步方式從目前數據流讀取位元組序列、依讀取的位元元組數目將數據流中的位置往前移,並監視取消要求。

(繼承來源 Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

從目前數據流讀取至少一個字節數目,並將數據流中的位置依讀取的位元組數目往前移。

(繼承來源 Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

以異步方式從目前數據流讀取至少一個字節數目、依讀取的位元組數目將數據流中的位置往前移,並監視取消要求。

(繼承來源 Stream)
ReadByte()

從目前的數據流讀取位元組。

ReadExactly(Byte[], Int32, Int32)

從目前數據流讀取 count 位元組數,並將位置往前移。

(繼承來源 Stream)
ReadExactly(Span<Byte>)

從目前的數據流讀取位元組,並將位置往前移,直到填入 buffer 為止。

(繼承來源 Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)

以異步方式從目前數據流讀取 count 位元組數目、推進數據流中的位置,以及監視取消要求。

(繼承來源 Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

以異步方式從目前數據流讀取位元組、將數據流中的位置往前移,直到填入 buffer,並監視取消要求。

(繼承來源 Stream)
Seek(Int64, SeekOrigin)

將目前數據流中的位置設定為指定的值。

SetLength(Int64)

將目前數據流的長度設定為指定的值。

ToArray()

不論 Position 屬性為何,將數據流內容寫入位元組陣列。

ToString()

傳回表示目前 物件的字串。

(繼承來源 Object)
TryGetBuffer(ArraySegment<Byte>)

傳回建立此數據流的未帶正負號位元組陣列。 傳回值表示轉換是否成功。

Write(Byte[], Int32, Int32)

使用從緩衝區讀取的數據,將位元組區塊寫入目前數據流。

Write(ReadOnlySpan<Byte>)

將包含在 source 的位元組序列寫入目前記憶體數據流中,並依寫入的位元組數目,將這個記憶體資料流中的目前位置往前移。

Write(ReadOnlySpan<Byte>)

在衍生類別中覆寫時,將位元組序列寫入目前數據流,並依寫入的位元組數目將這個數據流中的目前位置往前移。

(繼承來源 Stream)
WriteAsync(Byte[], Int32, Int32)

以異步方式將位元組序列寫入目前數據流,並依寫入的位元元組數目,將這個數據流中的目前位置往前移。

(繼承來源 Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

以異步方式將位元組序列寫入至目前的數據流、依寫入的位元組數目將這個數據流中的目前位置往前移,並監視取消要求。

WriteAsync(Byte[], Int32, Int32, CancellationToken)

以異步方式將位元組序列寫入至目前的數據流、依寫入的位元組數目將這個數據流中的目前位置往前移,並監視取消要求。

(繼承來源 Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

以異步方式將包含在 source 中的位元組序列寫入目前記憶體數據流、依寫入的位元組數目將這個記憶體資料流中的目前位置往前移,並監視取消要求。

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

以異步方式將位元組序列寫入至目前的數據流、依寫入的位元組數目將這個數據流中的目前位置往前移,並監視取消要求。

(繼承來源 Stream)
WriteByte(Byte)

將位元組寫入目前位置的目前數據流。

WriteTo(Stream)

將此記憶體數據流的整個內容寫入另一個數據流。

明確介面實作

IDisposable.Dispose()

釋放 Stream所使用的所有資源。

(繼承來源 Stream)

擴充方法

CopyToAsync(Stream, PipeWriter, CancellationToken)

使用取消標記,以異步方式從 Stream 讀取位元組,並將其寫入指定的 PipeWriter

AsInputStream(Stream)

將適用於 Windows 市集應用程式的 .NET 中的 Managed 資料流轉換為 Windows 執行時間中的輸入資料流。

AsOutputStream(Stream)

將適用於 Windows 市集應用程式的 .NET 中的 Managed 資料流轉換為 Windows 執行時間中的輸出資料流。

AsRandomAccessStream(Stream)

將指定的數據流轉換為隨機存取數據流。

GetWindowsRuntimeBuffer(MemoryStream)

傳回 Windows.Storage.Streams.IBuffer 介面,代表與指定記憶體數據流相同的記憶體。

GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)

會傳回 Windows.Storage.Streams.IBuffer 介面,代表指定記憶體數據流所代表記憶體內的區域。

ConfigureAwait(IAsyncDisposable, Boolean)

設定如何執行從異步可處置專案傳回的工作等候。

適用於

另請參閱