UnmanagedMemoryStream.Write Methode

Definition

Namespace:
System.IO
Assemblys:
netstandard.dll, System.Runtime.dll
Assembly:
System.Runtime.InteropServices.dll
Assembly:
netstandard.dll
Assemblys:
mscorlib.dll, System.IO.UnmanagedMemoryStream.dll
Assembly:
System.IO.UnmanagedMemoryStream.dll
Assembly:
mscorlib.dll

Überlädt

Name Beschreibung
Write(ReadOnlySpan<Byte>)

Schreibt einen Byteblock in den aktuellen nicht verwalteten Speicherstrom mithilfe von Daten aus der bereitgestellten Bytespanne.
Write(Byte[], Int32, Int32)

Schreibt einen Byteblock mithilfe von Daten aus einem Puffer in den aktuellen Datenstrom.

Write(ReadOnlySpan<Byte>)

Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs

Schreibt einen Byteblock in den aktuellen nicht verwalteten Speicherstrom mithilfe von Daten aus der bereitgestellten Bytespanne.

public:
 override void Write(ReadOnlySpan<System::Byte> buffer);
public:
 override void Write(ReadOnlySpan<System::Byte> source);
public override void Write(ReadOnlySpan<byte> buffer);
public override void Write(ReadOnlySpan<byte> source);
override this.Write : ReadOnlySpan<byte> -> unit
override this.Write : ReadOnlySpan<byte> -> unit
Public Overrides Sub Write (buffer As ReadOnlySpan(Of Byte))
Public Overrides Sub Write (source As ReadOnlySpan(Of Byte))

Parameter

sourcebuffer
ReadOnlySpan<Byte>

Die Spanne der Bytes, aus denen Bytes in den aktuellen nicht verwalteten Speicherdatenstrom kopiert werden sollen.

Gilt für:

Write(Byte[], Int32, Int32)

Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs
Quelle:
UnmanagedMemoryStream.cs

Schreibt einen Byteblock mithilfe von Daten aus einem Puffer in den aktuellen Datenstrom.

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)

Parameter

buffer
Byte[]

Das Bytearray, aus dem Bytes in den aktuellen Datenstrom kopiert werden sollen.

offset
Int32

Der Offset im Puffer, bei dem mit dem Kopieren von Bytes in den aktuellen Datenstrom begonnen werden soll.

count
Int32

Die Anzahl der Bytes, die in den aktuellen Datenstrom geschrieben werden sollen.

Ausnahmen

ObjectDisposedException

Der Datenstrom wird geschlossen.

NotSupportedException

Der zugrunde liegende Arbeitsspeicher unterstützt das Schreiben nicht.

-oder-

Es wird versucht, in den Datenstrom zu schreiben, und die CanWrite Eigenschaft ist false.

-oder-

Der count Wert ist größer als die Kapazität des Datenstroms.

-oder-

Die Position befindet sich am Ende der Datenstromkapazität.

IOException

Ein E/A-Fehler tritt auf.

ArgumentOutOfRangeException

Einer der angegebenen Parameter ist kleiner als Null.

ArgumentException

Der offset Parameter minus der Länge des buffer Parameters ist kleiner als der count Parameter.

ArgumentNullException

Der buffer Parameter ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie mithilfe der UnmanagedMemoryStream Klasse in nicht verwalteten Arbeitsspeicher lesen und schreiben. Ein Block des nicht verwalteten Speichers wird mithilfe der Marshal Klasse zugewiesen und aufgehoben.


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

Hinweise

Das Schreiben erfolgt an der aktuellen Position im Datenstrom.

Gilt für: