Stream.cs

#region Assembly mscorlib.dll, v4.0.30319
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll
#endregion

using System;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Threading;

namespace System.IO
{
    // Zusammenfassung:
    //     Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.
    [Serializable]
    [ComVisible(true)]
    public abstract class Stream : MarshalByRefObject, IDisposable
    {
        // Zusammenfassung:
        //     Ein Stream ohne Sicherungsspeicher.
        public static readonly Stream Null;

        // Zusammenfassung:
        //     Initialisiert eine neue Instanz der System.IO.Stream-Klasse.
        protected Stream();

        // Zusammenfassung:
        //     Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt,
        //     ob der aktuelle Stream Lesevorgänge unterstützt.
        //
        // Rückgabewerte:
        //     true, wenn der Stream Lesevorgänge unterstützt, andernfalls false.
        public abstract bool CanRead { get; }
        //
        // Zusammenfassung:
        //     Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt,
        //     ob der aktuelle Stream Suchvorgänge unterstützt.
        //
        // Rückgabewerte:
        //     true, wenn der Stream Suchvorgänge unterstützt, andernfalls false.
        public abstract bool CanSeek { get; }
        //
        // Zusammenfassung:
        //     Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout
        //     möglich ist.
        //
        // Rückgabewerte:
        //     Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist.
        [ComVisible(false)]
        public virtual bool CanTimeout { get; }
        //
        // Zusammenfassung:
        //     Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt,
        //     ob der aktuelle Stream Schreibvorgänge unterstützt.
        //
        // Rückgabewerte:
        //     true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false.
        public abstract bool CanWrite { get; }
        //
        // Zusammenfassung:
        //     Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams
        //     in Bytes ab.
        //
        // Rückgabewerte:
        //     Ein Long-Wert, der die Länge des Streams in Bytes darstellt.
        //
        // Ausnahmen:
        //   System.NotSupportedException:
        //     Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract long Length { get; }
        //
        // Zusammenfassung:
        //     Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen
        //     Stream ab oder legt diese fest.
        //
        // Rückgabewerte:
        //     Die aktuelle Position innerhalb des Streams.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Suchvorgänge.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract long Position { get; set; }
        //
        // Zusammenfassung:
        //     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.
        //
        // Rückgabewerte:
        //     Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge
        //     durchzuführen, bevor ein Timeout auftritt.
        //
        // Ausnahmen:
        //   System.InvalidOperationException:
        //     Die System.IO.Stream.ReadTimeout-Methode löst immer eine System.InvalidOperationException
        //     aus.
        [ComVisible(false)]
        public virtual int ReadTimeout { get; set; }
        //
        // Zusammenfassung:
        //     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.
        //
        // Rückgabewerte:
        //     Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge
        //     durchzuführen, bevor ein Timeout auftritt.
        //
        // Ausnahmen:
        //   System.InvalidOperationException:
        //     Die System.IO.Stream.WriteTimeout-Methode löst immer eine System.InvalidOperationException
        //     aus.
        [ComVisible(false)]
        public virtual int WriteTimeout { get; set; }

        // Zusammenfassung:
        //     Beginnt einen asynchronen Lesevorgang.
        //
        // Parameter:
        //   buffer:
        //     Der Puffer, in den die Daten gelesen werden sollen.
        //
        //   offset:
        //     Der Byteoffset im buffer, ab dem aus dem Stream gelesene Daten geschrieben
        //     werden.
        //
        //   count:
        //     Die maximale Anzahl der zu lesenden Bytes.
        //
        //   callback:
        //     Ein optionaler asynchroner Rückruf, der nach Abschluss des Lesevorgangs aufgerufen
        //     werden soll.
        //
        //   state:
        //     Ein vom Benutzer bereitgestelltes Objekt, das diese asynchrone Leseanforderung
        //     von anderen Anforderungen unterscheidet.
        //
        // Rückgabewerte:
        //     Ein System.IAsyncResult, das den asynchronen Lesevorgang darstellt, der möglicherweise
        //     noch aussteht.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Es wurde versucht, einen asynchronen Lesevorgang über das Ende des Streams
        //     hinaus durchzuführen, oder es ist ein Datenträgerfehler aufgetreten.
        //
        //   System.ArgumentException:
        //     Mindestens eines der Argumente ist ungültig.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        //
        //   System.NotSupportedException:
        //     Die aktuelle Stream-Implementierung unterstützt den Lesevorgang nicht.
        public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        //
        // Zusammenfassung:
        //     Beginnt einen asynchronen Schreibvorgang.
        //
        // Parameter:
        //   buffer:
        //     Der Puffer, aus dem Daten geschrieben werden sollen.
        //
        //   offset:
        //     Der Byteoffset im buffer, ab dem geschrieben werden soll.
        //
        //   count:
        //     Die maximale Anzahl der zu schreibenden Bytes.
        //
        //   callback:
        //     Ein optionaler asynchroner Rückruf, der nach Abschluss des Schreibvorgangs
        //     aufgerufen wird.
        //
        //   state:
        //     Ein vom Benutzer bereitgestelltes Objekt, das diese asynchrone Schreibanforderung
        //     von anderen Anforderungen unterscheidet.
        //
        // Rückgabewerte:
        //     Ein IAsyncResult, das den asynchronen Schreibvorgang darstellt, der möglicherweise
        //     noch aussteht.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Es wurde versucht, einen asynchronen Schreibvorgang über das Ende des Streams
        //     hinaus durchzuführen, oder es ist ein Datenträgerfehler aufgetreten.
        //
        //   System.ArgumentException:
        //     Mindestens eines der Argumente ist ungültig.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        //
        //   System.NotSupportedException:
        //     Die aktuelle Stream-Implementierung unterstützt den Schreibvorgang nicht.
        public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        //
        // Zusammenfassung:
        //     Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten
        //     Ressourcen frei (z. B. Sockets und Dateihandles).
        public virtual void Close();
        //
        // Zusammenfassung:
        //     Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie in den Zieldatenstrom.
        //
        // Parameter:
        //   destination:
        //     Der Datenstrom, der nach dem Vorgang den Inhalt des aktuellen Datenstroms
        //     enthält.
        //
        // Ausnahmen:
        //   System.ArgumentNullException:
        //     destination hat den Wert null.
        //
        //   System.NotSupportedException:
        //     Der aktuelle Stream unterstützt keine Lesevorgänge.– oder –destination unterstützt
        //     das Schreiben nicht.
        //
        //   System.ObjectDisposedException:
        //     Entweder der aktuelle Stream oder destination wurde geschlossen, bevor die
        //     System.IO.Stream.CopyTo(System.IO.Stream)-Methode aufgerufen wurde.
        //
        //   System.IO.IOException:
        //     Ein E/A-Fehler ist aufgetreten.
        public void CopyTo(Stream destination);
        //
        // Zusammenfassung:
        //     Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung
        //     einer angegebenen Puffergröße in einen Zieldatenstrom.
        //
        // Parameter:
        //   destination:
        //     Der Datenstrom, der nach dem Vorgang den Inhalt des aktuellen Datenstroms
        //     enthält.
        //
        //   bufferSize:
        //     Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße
        //     ist 4096.
        //
        // Ausnahmen:
        //   System.ArgumentNullException:
        //     destination hat den Wert null.
        //
        //   System.ArgumentOutOfRangeException:
        //     bufferSize ist negativ oder 0 (null).
        //
        //   System.NotSupportedException:
        //     Der aktuelle Stream unterstützt keine Lesevorgänge.– oder –destination unterstützt
        //     das Schreiben nicht.
        //
        //   System.ObjectDisposedException:
        //     Entweder der aktuelle Stream oder destination wurde geschlossen, bevor die
        //     System.IO.Stream.CopyTo(System.IO.Stream)-Methode aufgerufen wurde.
        //
        //   System.IO.IOException:
        //     Ein E/A-Fehler ist aufgetreten.
        public void CopyTo(Stream destination, int bufferSize);
        //
        // Zusammenfassung:
        //     Reserviert ein System.Threading.WaitHandle-Objekt.
        //
        // Rückgabewerte:
        //     Ein Verweis auf das reservierte WaitHandle.
        [Obsolete(@"CreateWaitHandle will be removed eventually.  Please use ""new ManualResetEvent(false)"" instead.")]
        protected virtual WaitHandle CreateWaitHandle();
        //
        // Zusammenfassung:
        //     Gibt sämtliche vom System.IO.Stream verwendeten Ressourcen frei.
        public void Dispose();
        //
        // Zusammenfassung:
        //     Gibt die vom System.IO.Stream verwendeten nicht verwalteten Ressourcen und
        //     optional auch die verwalteten Ressourcen frei.
        //
        // Parameter:
        //   disposing:
        //     true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben.
        //     false, um ausschließlich nicht verwaltete Ressourcen freizugeben.
        protected virtual void Dispose(bool disposing);
        //
        // Zusammenfassung:
        //     Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist.
        //
        // Parameter:
        //   asyncResult:
        //     Der Verweis auf die ausstehende asynchrone Anforderung, die beendet werden
        //     soll.
        //
        // Rückgabewerte:
        //     Die Anzahl der aus dem Stream gelesenen Bytes. Diese Anzahl kann zwischen
        //     0 und der Anzahl der angeforderten Bytes liegen.Streams geben nur am Ende
        //     des Streams 0 zurück, andernfalls sollten sie blockieren, bis mindestens
        //     1 Byte verfügbar ist.
        //
        // Ausnahmen:
        //   System.ArgumentNullException:
        //     asyncResult hat den Wert null.
        //
        //   System.ArgumentException:
        //     asyncResult stammt nicht von einer System.IO.Stream.BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)-Methode
        //     im aktuellen Stream.
        //
        //   System.IO.IOException:
        //     Der Stream ist geschlossen, oder ein interner Fehler ist aufgetreten.
        public virtual int EndRead(IAsyncResult asyncResult);
        //
        // Zusammenfassung:
        //     Beendet einen asynchronen Schreibvorgang.
        //
        // Parameter:
        //   asyncResult:
        //     Ein Verweis auf die ausstehende asynchrone E/A-Anforderung.
        //
        // Ausnahmen:
        //   System.ArgumentNullException:
        //     asyncResult hat den Wert null.
        //
        //   System.ArgumentException:
        //     asyncResult stammt nicht von einer System.IO.Stream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)-Methode
        //     im aktuellen Stream.
        //
        //   System.IO.IOException:
        //     Der Stream ist geschlossen, oder ein interner Fehler ist aufgetreten.
        public virtual void EndWrite(IAsyncResult asyncResult);
        //
        // Zusammenfassung:
        //     Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen
        //     Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde
        //     liegende Gerät.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        public abstract void Flush();
        //
        // Zusammenfassung:
        //     Bietet Unterstützung für das System.Diagnostics.Contracts.Contract.
        protected virtual void ObjectInvariant();
        //
        // Zusammenfassung:
        //     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.
        //
        // Parameter:
        //   buffer:
        //     Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene
        //     Bytearray mit den Werten zwischen offset und (offset + count - 1), die durch
        //     aus der aktuellen Quelle gelesene Bytes ersetzt wurden.
        //
        //   offset:
        //     Der nullbasierte Byteoffset im buffer, ab dem die aus dem aktuellen Stream
        //     gelesenen Daten gespeichert werden.
        //
        //   count:
        //     Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden
        //     sollen.
        //
        // Rückgabewerte:
        //     Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als
        //     die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit
        //     nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist.
        //
        // Ausnahmen:
        //   System.ArgumentException:
        //     Die Summe aus offset und count ist größer als die Pufferlänge.
        //
        //   System.ArgumentNullException:
        //     buffer hat den Wert null.
        //
        //   System.ArgumentOutOfRangeException:
        //     offset oder count ist negativ.
        //
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Lesevorgänge.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract int Read(byte[] buffer, int offset, int count);
        //
        // Zusammenfassung:
        //     Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte,
        //     oder gibt -1 zurück, wenn das Ende des Streams erreicht ist.
        //
        // Rückgabewerte:
        //     Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des
        //     Streams erreicht ist.
        //
        // Ausnahmen:
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Lesevorgänge.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public virtual int ReadByte();
        //
        // Zusammenfassung:
        //     Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen
        //     Stream fest.
        //
        // Parameter:
        //   offset:
        //     Ein Byteoffset relativ zum origin-Parameter.
        //
        //   origin:
        //     Ein Wert vom Typ System.IO.SeekOrigin, der den Bezugspunkt angibt, von dem
        //     aus die neue Position ermittelt wird.
        //
        // Rückgabewerte:
        //     Die neue Position innerhalb des aktuellen Streams.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall,
        //     wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract long Seek(long offset, SeekOrigin origin);
        //
        // Zusammenfassung:
        //     Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen
        //     Streams fest.
        //
        // Parameter:
        //   value:
        //     Die gewünschte Länge des aktuellen Streams in Bytes.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies
        //     ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe
        //     erstellt wird.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract void SetLength(long value);
        //
        // Zusammenfassung:
        //     Erstellt um das angegebene System.IO.Stream-Objekt einen threadsicheren (synchronisierten)
        //     Wrapper.
        //
        // Parameter:
        //   stream:
        //     Das System.IO.Stream-Objekt, das synchronisiert werden soll.
        //
        // Rückgabewerte:
        //     Ein threadsicheres System.IO.Stream-Objekt.
        //
        // Ausnahmen:
        //   System.ArgumentNullException:
        //     stream hat den Wert null.
        public static Stream Synchronized(Stream stream);
        //
        // Zusammenfassung:
        //     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.
        //
        // Parameter:
        //   buffer:
        //     Ein Bytearray.Diese Methode kopiert count Bytes aus dem buffer in den aktuellen
        //     Stream.
        //
        //   offset:
        //     Der nullbasierte Byteoffset im buffer, ab dem Bytes in den aktuellen Stream
        //     kopiert werden.
        //
        //   count:
        //     Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen.
        //
        // Ausnahmen:
        //   System.ArgumentException:
        //     Die Summe aus offset und count ist größer als die Pufferlänge.
        //
        //   System.ArgumentNullException:
        //     buffer hat den Wert null.
        //
        //   System.ArgumentOutOfRangeException:
        //     offset oder count ist negativ.
        //
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Schreibvorgänge.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public abstract void Write(byte[] buffer, int offset, int count);
        //
        // Zusammenfassung:
        //     Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle
        //     Position im Stream um ein Byte.
        //
        // Parameter:
        //   value:
        //     Das Byte, das in den Stream geschrieben werden soll.
        //
        // Ausnahmen:
        //   System.IO.IOException:
        //     Ein E/A-Fehler tritt auf.
        //
        //   System.NotSupportedException:
        //     Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen.
        //
        //   System.ObjectDisposedException:
        //     Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde.
        public virtual void WriteByte(byte value);
    }
}