UnmanagedMemoryStream.Write Methode

Definitie

Naamruimte:

System.IO

Assembly:

mscorlib.dll

Overloads

Name	Description
Write(Byte[], Int32, Int32)	Hiermee schrijft u een blok bytes naar de huidige stroom met behulp van gegevens uit een buffer.

Write(Byte[], Int32, Int32)

Hiermee schrijft u een blok bytes naar de huidige stroom met behulp van gegevens uit een buffer.

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)

Parameters

buffer

Byte[]

De bytematrix waaruit bytes naar de huidige stroom moeten worden gekopieerd.

offset

Int32

De offset in de buffer waarop bytes naar de huidige stroom moeten worden gekopieerd.

count

Int32

Het aantal bytes dat naar de huidige stroom moet worden geschreven.

Uitzonderingen

ObjectDisposedException

De stream is gesloten.

NotSupportedException

Het onderliggende geheugen biedt geen ondersteuning voor schrijven.

– of –

Er wordt geprobeerd om naar de stream te schrijven en de CanWrite eigenschap is false.

– of –

De count waarde is groter dan de capaciteit van de stream.

– of –

De positie bevindt zich aan het einde van de stroomcapaciteit.

IOException

Er treedt een I/O-fout op.

ArgumentOutOfRangeException

Een van de opgegeven parameters is kleiner dan nul.

ArgumentException

De offset parameter min de lengte van de buffer parameter is kleiner dan de count parameter.

ArgumentNullException

De buffer parameter is null.

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u kunt lezen van en schrijven naar onbeheerd geheugen met behulp van de UnmanagedMemoryStream klasse. Er wordt een blok niet-beheerde geheugen toegewezen en de toewijzing ongedaan gemaakt met behulp van de Marshal klasse.

// 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();
    }
}

Opmerkingen

Schrijven vindt plaats op de huidige positie in de stroom.