MemoryStream Klasse

Referenz

Definition

Namespace:: System.IO

Assembly:: System.IO.dll

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.

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

Vererbung: Object

Stream
MemoryStream

Vererbung: Object

MarshalByRefObject

Stream
MemoryStream

Attribute: SerializableAttribute ComVisibleAttribute

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Daten mithilfe des Speichers als Sicherungsspeicher gelesen und geschrieben werden.

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

Hinweise

Die aktuelle Position eines Datenstroms ist die Position, an der der nächste Lese- oder Schreibvorgang stattfinden könnte. Die aktuelle Position kann über die Seek Methode abgerufen oder festgelegt werden. Wenn eine neue Instanz MemoryStream erstellt wird, wird die aktuelle Position auf Null festgelegt.

Hinweis

Dieser Typ implementiert die IDisposable-Schnittstelle, verfügt aber nicht über löschbare Ressourcen. Dies bedeutet, dass es nicht nötig ist, ihn zu löschen, indem Sie Dispose() direkt aufrufen, oder indem Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic).

Speicherströme, die mit einem nicht signierten Bytearray erstellt wurden, stellen einen nicht resisierbaren Datenstrom bereit. Wenn Sie ein Bytearray verwenden, können Sie den Datenstrom weder anfügen noch verkleinern, obwohl Sie möglicherweise den vorhandenen Inhalt je nach den Parametern ändern können, die in den Konstruktor übergeben wurden. Leere Speicherströme sind verfügbar und können in und gelesen werden.

Wenn ein MemoryStream Objekt einer ResX-Datei oder einer Ressourcendatei hinzugefügt wird, rufen Sie die GetStream Methode zur Laufzeit auf, um sie abzurufen.

Wenn ein MemoryStream Objekt in einer Ressourcendatei serialisiert wird, wird es tatsächlich als UnmanagedMemoryStreamserialisiert. Dieses Verhalten bietet eine bessere Leistung sowie die Möglichkeit, einen Zeiger direkt auf die Daten zu erhalten, ohne Methoden durchlaufen Stream zu müssen.

Konstruktoren

MemoryStream()	Initialisiert eine neue Instanz der MemoryStream-Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde.
MemoryStream(Byte[])	Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der MemoryStream-Klasse, deren Größe nicht geändert werden kann.
MemoryStream(Byte[], Boolean)	Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der MemoryStream-Klasse, deren Größe nicht geändert werden kann, wobei die CanWrite-Eigenschaft wie angegeben festgelegt wird.
MemoryStream(Byte[], Int32, Int32)	Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der MemoryStream-Klasse, deren Größe nicht geändert werden kann.
MemoryStream(Byte[], Int32, Int32, Boolean)	Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der MemoryStream-Klasse, deren Größe nicht geändert werden kann, wobei die CanWrite-Eigenschaft wie angegeben festgelegt wurde.
MemoryStream(Byte[], Int32, Int32, Boolean, Boolean)	Initialisiert eine neue Instanz der MemoryStream-Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die CanWrite-Eigenschaft und die Möglichkeit zum Aufruf von GetBuffer() wie angegeben festgelegt werden.
MemoryStream(Int32)	Initialisiert eine neue Instanz der MemoryStream-Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird.

Eigenschaften

CanRead	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt.
CanSeek	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt.
CanTimeout	Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. (Geerbt von Stream)
CanWrite	Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt.
Capacity	Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest.
Length	Ruft die Länge des Streams in Bytes ab.
Position	Ruft die aktuelle Position im Stream ab oder legt diese fest.
ReadTimeout	Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Geerbt von Stream)
WriteTimeout	Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. (Geerbt von Stream)

Methoden

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).)
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
Close()	Schließt den Stream für das Lesen und Schreiben.
Close()	Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird. (Geerbt von Stream)
CopyTo(Stream)	Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. (Geerbt von Stream)
CopyTo(Stream, Int32)	Liest alles Bytes aus dem aktuellen Speicherdatenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom.
CopyTo(Stream, Int32)	Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. (Geerbt von Stream)
CopyToAsync(Stream)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. (Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream. (Geerbt von Stream)
CopyToAsync(Stream, Int32)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. (Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream.
CopyToAsync(Stream, Int32, CancellationToken)	Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. (Geerbt von Stream)
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
CreateWaitHandle()	Veraltet. Veraltet. Reserviert ein WaitHandle-Objekt. (Geerbt von Stream)
Dispose()	Gibt alle vom Stream verwendeten Ressourcen frei. (Geerbt von Stream)
Dispose(Boolean)	Gibt die von der MemoryStream-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei.
Dispose(Boolean)	Gibt die von Stream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Stream)
DisposeAsync()	Gibt die nicht verwalteten Ressourcen, die von der Stream verwendet werden, asynchron frei. (Geerbt von Stream)
EndRead(IAsyncResult)	Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32, CancellationToken).)
EndRead(IAsyncResult)	Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
EndWrite(IAsyncResult)	Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32, CancellationToken).)
EndWrite(IAsyncResult)	Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).) (Geerbt von Stream)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Flush()	Überschreibt die Flush()-Methode, sodass keine Aktion durchgeführt wird.
FlushAsync()	Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. (Geerbt von Stream)
FlushAsync(CancellationToken)	Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen.
FlushAsync(CancellationToken)	Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. (Geerbt von Stream)
GetBuffer()	Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ObjectInvariant()	Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht. Bietet Unterstützung für einen Contract.
ObjectInvariant()	Veraltet. Bietet Unterstützung für einen Contract. (Geerbt von Stream)
Read(Byte[], Int32, Int32)	Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer.
Read(Span<Byte>)	Liest eine Bytesequenz aus dem aktuellen Speicherdatenstrom und setzt die Position in diesem Speicherdatenstrom um die Anzahl der gelesenen Bytes nach vorn.
Read(Span<Byte>)	Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32)	Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. (Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Liest eine Folge von Bytes asynchron aus dem aktuellen Speicherdatenstrom, schreibt diese in `destination`, erhöht die Position im Speicherdatenstrom um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen.
ReadAsync(Memory<Byte>, CancellationToken)	Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. (Geerbt von Stream)
ReadByte()	Liest ein Byte aus dem aktuellen Stream.
Seek(Int64, SeekOrigin)	Legt die Position im aktuellen Stream auf den angegebenen Wert fest.
SetLength(Int64)	Legt die Länge des aktuellen Streams auf den angegebenen Wert fest.
ToArray()	Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der Position-Eigenschaft.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryGetBuffer(ArraySegment<Byte>)	Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde. Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
Write(Byte[], Int32, Int32)	Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream.
Write(ReadOnlySpan<Byte>)	Schreibt die Bytesequenz, die in `source` enthalten ist, in den aktuellen Speicherdatenstrom und setzt die aktuelle Position in diesem Speicherdatenstrom um die Anzahl der geschriebenen Bytes nach vorn.
Write(ReadOnlySpan<Byte>)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32)	Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. (Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt die Bytesequenz, die in `source` enthalten ist, in den aktuellen Speicherdatenstrom, erhöht die aktuelle Position im Speicherdatenstrom um die Anzahl geschriebener Bytes und überwacht Abbruchanforderungen.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. (Geerbt von Stream)
WriteByte(Byte)	Schreibt ein Byte an die aktuelle Position im aktuellen Stream.
WriteTo(Stream)	Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Gibt alle vom Stream verwendeten Ressourcen frei.

(Geerbt von Stream)

Erweiterungsmethoden

AsInputStream(Stream)	Konvertiert einen verwalteten Stream in .NET für Microsoft Store-Apps in einen Eingabestream in der Windows-Runtime.
AsOutputStream(Stream)	Konvertiert einen verwalteten Stream in .NET für Microsoft Store-Apps in einen Ausgabestream in der Windows-Runtime.
AsRandomAccessStream(Stream)	Konvertiert den angegebenen Stream in einen Random-Access-Stream.
GetWindowsRuntimeBuffer(MemoryStream)	Gibt eine Windows.Storage.Streams.IBuffer-Schnittstelle zurück, die den gleichen Speicher wie der angegebene Speicherstream darstellt.
GetWindowsRuntimeBuffer(MemoryStream, Int32, Int32)	Gibt eine Windows.Storage.Streams.IBuffer-Schnittstelle zurück, die den Speicherbereich des angegebenen Speicherstreams darstellt.
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für