UnmanagedMemoryStream.Write Metod

Definition

Namnområde:

System.IO

Sammansättning:

mscorlib.dll

Överlagringar

Name	Description
Write(Byte[], Int32, Int32)	Skriver ett byteblock till den aktuella strömmen med data från en buffert.

Write(Byte[], Int32, Int32)

Skriver ett byteblock till den aktuella strömmen med data från en buffert.

public:
 override void Write(cli::array <System::Byte> ^ buffer, int offset, int count);

public override void Write(byte[] buffer, int offset, int count);

override this.Write : byte[] * int * int -> unit

Public Overrides Sub Write (buffer As Byte(), offset As Integer, count As Integer)

Parametrar

buffer

Byte[]

Bytematrisen som byte ska kopieras från till den aktuella strömmen.

offset

Int32

Förskjutningen i bufferten där byte ska börja kopieras till den aktuella strömmen.

count

Int32

Antalet byte som ska skrivas till den aktuella strömmen.

Undantag

ObjectDisposedException

Strömmen är stängd.

NotSupportedException

Det underliggande minnet stöder inte skrivning.

-eller-

Ett försök görs att skriva till strömmen och egenskapen CanWrite är false.

-eller-

Värdet count är större än strömmens kapacitet.

-eller-

Positionen är i slutet av strömkapaciteten.

IOException

Ett I/O-fel inträffar.

ArgumentOutOfRangeException

En av de angivna parametrarna är mindre än noll.

ArgumentException

Parametern offset minus parameterns buffer längd är mindre än parametern count .

ArgumentNullException

Parametern buffer är null.

Exempel

Följande kodexempel visar hur du läser från och skriver till ohanterat minne med hjälp av UnmanagedMemoryStream klassen. Ett block med ohanterat minne allokeras och avallokeras med hjälp av Marshal klassen.

// Note: you must compile this sample using the unsafe flag.
// From the command line, type the following: csc sample.cs /unsafe

using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;

unsafe class TestWriter
{
    static void Main()
    {
        // Create some data to read and write.
        byte[] message = UnicodeEncoding.Unicode.GetBytes("Here is some data.");

        // Allocate a block of unmanaged memory and return an IntPtr object.	
        IntPtr memIntPtr = Marshal.AllocHGlobal(message.Length);

        // Get a byte pointer from the IntPtr object.
        byte* memBytePtr = (byte*)memIntPtr.ToPointer();

        // Create an UnmanagedMemoryStream object using a pointer to unmanaged memory.
        UnmanagedMemoryStream writeStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Write);

        // Write the data.
        writeStream.Write(message, 0, message.Length);

        // Close the stream.
        writeStream.Close();

        // Create another UnmanagedMemoryStream object using a pointer to unmanaged memory.
        UnmanagedMemoryStream readStream = new UnmanagedMemoryStream(memBytePtr, message.Length, message.Length, FileAccess.Read);

        // Create a byte array to hold data from unmanaged memory.
        byte[] outMessage = new byte[message.Length];

        // Read from unmanaged memory to the byte array.
        readStream.Read(outMessage, 0, message.Length);

        // Close the stream.
        readStream.Close();

        // Display the data to the console.
        Console.WriteLine(UnicodeEncoding.Unicode.GetString(outMessage));

        // Free the block of unmanaged memory.
        Marshal.FreeHGlobal(memIntPtr);

        Console.ReadLine();
    }
}

Kommentarer

Skrivning sker på den aktuella positionen i strömmen.