MemoryStream Sınıf

Tanım

Ad Alanı:

System.IO

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

MemoryStream.cs

Yedekleme deposu bellek olan bir akış oluşturur.

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

public class MemoryStream : System.IO.Stream

type MemoryStream = class
    inherit Stream

Public Class MemoryStream
Inherits Stream

Devralma

Object

MarshalByRefObject

Stream

MemoryStream

Örnekler

Aşağıdaki kod örneğinde, yedekleme deposu olarak bellek kullanılarak verilerin nasıl okunduğu ve yazılması gösterilmektedir.

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

Açıklamalar

Akışın geçerli konumu, bir sonraki okuma veya yazma işleminin gerçekleşebileceği konumdur. Geçerli konum Seek yöntemi aracılığıyla alınabilir veya ayarlanabilir. Yeni bir MemoryStream örneği oluşturulduğunda geçerli konum sıfır olarak ayarlanır.

Not

Bu tür IDisposable arabirimini uygular, ancak aslında atılacak kaynağı yoktur. Bu, Dispose() doğrudan çağırarak veya using (C#'de) veya Using (Visual Basic'te) gibi bir dil yapısı kullanarak bunu yok etmenin gerekli olmadığı anlamına gelir.

İmzasız bayt dizisiyle oluşturulan bellek akışları, verilerin yeniden boyutlandırılamayan bir akışını sağlar. Bayt dizisi kullanırken, oluşturucuya geçirilen parametrelere bağlı olarak var olan içeriği değiştirebilmenize rağmen akışın sonuna ekleyemez veya daraltamazsınız. Boş bellek akışları yeniden boyutlandırılabilir ve öğesine yazılabilir ve buradan okunabilir.

ResX dosyasına veya .resources dosyasına bir MemoryStream nesnesi eklenirse, çalışma zamanında GetStream yöntemini çağırarak alın.

bir MemoryStream nesnesi bir kaynak dosyasına seri hale getirilirse, aslında UnmanagedMemoryStreamolarak seri hale getirilir. Bu davranış, Stream yöntemleri kullanmak zorunda kalmadan verilerin doğrudan işaretçisini alma özelliğinin yanı sıra daha iyi performans sağlar.

Oluşturucular

MemoryStream()	sıfıra başlatılan genişletilebilir kapasiteyle MemoryStream sınıfının yeni bir örneğini başlatır.
MemoryStream(Byte[])	Belirtilen bayt dizisini temel alarak MemoryStream sınıfının yeniden boyutlandırılamayan yeni bir örneğini başlatır.
MemoryStream(Byte[], Boolean)	belirtilen bayt dizisini temel alarak MemoryStream sınıfının yeniden boyutlandırılamayan yeni bir örneğini, belirtilen şekilde ayarlanmış CanWrite özelliğiyle başlatır.
MemoryStream(Byte[], Int32, Int32)	Bir bayt dizisinin belirtilen bölgesini (dizini) temel alarak MemoryStream sınıfının yeniden boyutlandırılamayan yeni bir örneğini başlatır.
MemoryStream(Byte[], Int32, Int32, Boolean)	bir bayt dizisinin belirtilen bölgesine göre MemoryStream sınıfının yeniden boyutlandırılamayan yeni bir örneğini başlatır ve CanWrite özelliği belirtilen şekilde ayarlanır.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	MemoryStream sınıfının yeni bir örneğini bayt dizisinin belirtilen bölgesine göre başlatır; CanWrite özelliği belirtildiği gibi ayarlanır ve belirtilen şekilde ayarlanmış GetBuffer() çağırabilir.
MemoryStream(Int32)	MemoryStream sınıfının yeni bir örneğini, belirtilen şekilde başlatılan genişletilebilir kapasiteyle başlatır.

Özellikler

CanRead	Geçerli akışın okumayı destekleyip desteklemediğini belirten bir değer alır.
CanSeek	Geçerli akışın aramayı destekleyip desteklemediğini belirten bir değer alır.
CanTimeout	Geçerli akışın zaman aşımına neden olup olmadığını belirleyen bir değer alır. (Devralındığı yer: Stream)
CanWrite	Geçerli akışın yazmayı destekleyip desteklemediğini belirten bir değer alır.
Capacity	Bu akış için ayrılan bayt sayısını alır veya ayarlar.
Length	Akışın bayt cinsinden uzunluğunu alır.
Position	Akış içindeki geçerli konumu alır veya ayarlar.
ReadTimeout	Akışın zaman aşımına uğramadan önce ne kadar süreyle okumayı deneyeceğini belirleyen bir değeri milisaniye cinsinden alır veya ayarlar. (Devralındığı yer: Stream)
WriteTimeout	Akışın zaman aşımına uğramadan önce ne kadar süreyle yazmaya çalışacağını belirleyen bir değeri milisaniye cinsinden alır veya ayarlar. (Devralındığı yer: Stream)

Yöntemler

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zaman uyumsuz bir okuma işlemi başlatır. (Bunun yerine ReadAsync(Byte[], Int32, Int32, CancellationToken) kullanmayı düşünün.)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Zaman uyumsuz bir yazma işlemi başlatır. (Bunun yerine WriteAsync(Byte[], Int32, Int32, CancellationToken) kullanmayı düşünün.)
Close()	Geçerli akışı kapatır ve geçerli akışla ilişkili tüm kaynakları (yuvalar ve dosya tanıtıcıları gibi) serbest bırakır. Bu yöntemi çağırmak yerine akışın düzgün şekilde atıldığından emin olun. (Devralındığı yer: Stream)
CopyTo(Stream)	Geçerli akıştan baytları okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyTo(Stream, Int32)	Geçerli bellek akışındaki baytları okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar.
CopyToAsync(Stream)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, CancellationToken)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen iptal belirtecini kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Belirtilen arabellek boyutu ve iptal belirtecini kullanarak geçerli akıştan tüm baytları zaman uyumsuz olarak okur ve başka bir akışa yazar.
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
CreateWaitHandle()	Geçersiz. bir WaitHandle nesnesi ayırır. (Devralındığı yer: Stream)
Dispose()	Streamtarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Stream)
Dispose(Boolean)	MemoryStream sınıfı tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.
DisposeAsync()	Streamtarafından kullanılan yönetilmeyen kaynakları zaman uyumsuz olarak serbest bırakır. (Devralındığı yer: Stream)
EndRead(IAsyncResult)	Bekleyen zaman uyumsuz okumanın tamamlanmasını bekler. (Bunun yerine ReadAsync(Byte[], Int32, Int32, CancellationToken) kullanmayı düşünün.)
EndWrite(IAsyncResult)	Zaman uyumsuz yazma işlemini sonlandırır. (Bunun yerine WriteAsync(Byte[], Int32, Int32, CancellationToken) kullanmayı düşünün.)
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Flush()	Hiçbir eylem gerçekleştirilmesi için Flush() yöntemini geçersiz kılar.
FlushAsync()	Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler ve arabelleğe alınan verilerin temel alınan cihaza yazılmasına neden olur. (Devralındığı yer: Stream)
FlushAsync(CancellationToken)	Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler ve iptal isteklerini izler.
GetBuffer()	Bu akışın oluşturulduğu işaretsiz bayt dizisini döndürür.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
ObjectInvariant()	Geçersiz. Contractiçin destek sağlar. (Devralındığı yer: Stream)
Read(Byte[], Int32, Int32)	Geçerli akıştan bir bayt bloğu okur ve verileri arabelleğe yazar.
Read(Span<Byte>)	Geçerli bellek akışından bir bayt dizisi okur ve bellek akışındaki konumu okunan bayt sayısına göre ilerler.
ReadAsync(Byte[], Int32, Int32)	Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur, okunan bayt sayısına göre akış içindeki konumu ilerletir ve iptal isteklerini izler.
ReadAsync(Memory<Byte>, CancellationToken)	Geçerli bellek akışından bir bayt dizisini zaman uyumsuz olarak okur, diziyi destinationyazar, bellek akışındaki konumu okunan bayt sayısıyla ilerletir ve iptal isteklerini izler.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Geçerli akıştan en az bayt sayısını okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Geçerli akıştan en az en az sayıda bayt zaman uyumsuz olarak okur, okunan bayt sayısına göre akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadByte()	Geçerli akıştan bir bayt okur.
ReadExactly(Byte[], Int32, Int32)	Geçerli akıştan count bayt sayısını okur ve akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactly(Span<Byte>)	Geçerli akıştan baytları okur ve buffer doldurulana kadar akıştaki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Geçerli akıştan count bayt sayısını zaman uyumsuz olarak okur, akış içindeki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Geçerli akıştaki baytları zaman uyumsuz olarak okur, buffer doldurulana kadar akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)	Geçerli akış içindeki konumu belirtilen değere ayarlar.
SetLength(Int64)	Geçerli akışın uzunluğunu belirtilen değere ayarlar.
ToArray()	Position özelliğinden bağımsız olarak akış içeriğini bir bayt dizisine yazar.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
TryGetBuffer(ArraySegment<Byte>)	Bu akışın oluşturulduğu işaretsiz bayt dizisini döndürür. Dönüş değeri, dönüştürmenin başarılı olup olmadığını gösterir.
Write(Byte[], Int32, Int32)	Arabellekten okunan verileri kullanarak geçerli akışa bir bayt bloğu yazar.
Write(ReadOnlySpan<Byte>)	source içindeki bayt dizisini geçerli bellek akışına yazar ve bu bellek akışındaki geçerli konumu yazılan bayt sayısı kadar ilerletir.
WriteAsync(Byte[], Int32, Int32)	Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar ve bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar, bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir ve iptal isteklerini izler.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	source içindeki bayt dizisini zaman uyumsuz olarak geçerli bellek akışına yazar, bu bellek akışındaki geçerli konumu yazılan bayt sayısına göre ilerletir ve iptal isteklerini izler.
WriteByte(Byte)	Geçerli akışa geçerli konumda bir bayt yazar.
WriteTo(Stream)	Bu bellek akışının tüm içeriğini başka bir akışa yazar.

Uzantı Metotları

CopyToAsync(Stream, PipeWriter, CancellationToken)	Stream baytları zaman uyumsuz olarak okur ve bir iptal belirteci kullanarak belirtilen PipeWriteryazar.
ConfigureAwait(IAsyncDisposable, Boolean)	Zaman uyumsuz bir atılabilir öğeden döndürülen görevlerde awaits işleminin nasıl gerçekleştirileceğini yapılandırılır.

Ayrıca bkz.

• Dosya ve Akış G/Ç
• Nasıl yapılır: Dosya Metin Okuma
• Nasıl yapılır: Dosya Metin Yazma