Kontinuierlich Lesen von einem stream???

Habe ich ein Stream-Objekt wird gelegentlich einige Daten über Sie, sondern in unvorhersehbaren Abständen. Nachrichten, die angezeigt auf dem Stream sind gut definiert, und deklarieren Sie die Größe Ihrer Nutzlast im Voraus (die Größe ist ein 16-bit-integer enthalten in den ersten beiden bytes jeder Nachricht).

Ich würde gerne eine StreamWatcher Klasse, die erkennt, wenn der Stream hat einige Daten über Sie. Sobald es funktioniert, ich möchte, dass ein Ereignis ausgelöst werden, so dass eine abonnierte StreamProcessor-Instanz Bearbeiten können Sie die neue Nachricht.

Kann das mit C# - Veranstaltungen ohne Verwendung von Threads direkt? Es scheint, wie es einfach sein sollte, aber ich kann Sie nicht so Recht, meinen Kopf um den richtigen Weg zu entwerfen.

InformationsquelleAutor Damien Wildfire | 2010-05-06

asynchronous c#events streaming

14

Wenn Sie sagen, nicht verwenden, threads direkt, ich nehme an, Sie wollen immer noch, Sie zu benutzen indirekt über asynchrone Aufrufe, sonst wäre dies nicht sehr sinnvoll.

Alles, was Sie tun müssen, ist, wickeln Sie die async-Methoden der Stream und speichern das Ergebnis in einem Puffer. Zunächst definieren wir die event-Teil der spec:
```
public delegate void MessageAvailableEventHandler(object sender,
    MessageAvailableEventArgs e);

public class MessageAvailableEventArgs : EventArgs
{
    public MessageAvailableEventArgs(int messageSize) : base()
    {
        this.MessageSize = messageSize;
    }

    public int MessageSize { get; private set; }
}
```
Nun, Lesen Sie ein 16-bit-integer aus dem stream asynchron und berichten, wenn es fertig ist:
```
public class StreamWatcher
{
    private readonly Stream stream;

    private byte[] sizeBuffer = new byte[2];

    public StreamWatcher(Stream stream)
    {
        if (stream == null)
            throw new ArgumentNullException("stream");
        this.stream = stream;
        WatchNext();
    }

    protected void OnMessageAvailable(MessageAvailableEventArgs e)
    {
        var handler = MessageAvailable;
        if (handler != null)
            handler(this, e);
    }

    protected void WatchNext()
    {
        stream.BeginRead(sizeBuffer, 0, 2, new AsyncCallback(ReadCallback),
            null);
    }

    private void ReadCallback(IAsyncResult ar)
    {
        int bytesRead = stream.EndRead(ar);
        if (bytesRead != 2)
            throw new InvalidOperationException("Invalid message header.");
        int messageSize = sizeBuffer[1] << 8 + sizeBuffer[0];
        OnMessageAvailable(new MessageAvailableEventArgs(messageSize));
        WatchNext();
    }

    public event MessageAvailableEventHandler MessageAvailable;
}
```
Ich denke, das ist über es. Dies setzt Voraus, dass-je nachdem welche Klasse ist der Umgang mit der Nachricht hat auch Zugang zu den Stream ist und bereit ist, es zu Lesen, synchron oder asynchron, basierend auf die Nachricht, die Größe der Veranstaltung. Wenn Sie möchten, dass der watcher-Klasse tatsächlich Lesen Sie die gesamte Nachricht, dann haben Sie etwas mehr code zu tun.
- +1 für die Umsetzung, die beweist meine Theorie von BeginRead ist nicht die richtige Lösung. Ihre Umsetzung geklärt, dass Zweifel.
- Herrlich! Dieses sieht wie es wird den trick tun, und ich werde versuchen es heraus morgen.
- +1. Erbsenzählerei: AFAIK einen Stream.Lesen ist erlaubt, zu kehren weniger als count bytes, solange es gibt mindestens ein byte (wenn man das Ende nicht erreicht). Also, wenn (bytesRead != 2) Sie sollten nicht eine Ausnahme werfen, aber BeginRead erst wieder zwei bytes, die gelesen wurden.
- Das ist ein guter Punkt - es hängt davon ab auf den stream. Einige blockieren, bis die Daten verfügbar sind, andere werden zurück früh, und andere, die immer noch eine Ausnahme. Um diese Arbeit mit beliebiger - stream, ich glaube, Sie würde wählen müssen, die das Verhalten in den Konstruktor.
- Wollen Sie nicht OnMessageAvailable angehoben werden, bevor WatchNext im ReadCallback?
- Ich denke, du hast Recht - das war, wie ich ursprünglich hatte, dann habe ich die umgekehrte Reihenfolge, weil ich mir dachte, es würde geben einen besseren Durchsatz, aber ich merke jetzt, dass es schafft eine potentielle race-condition, wenn der Verbraucher benötigt, um tatsächlich Lesen mehr Daten aus dem stream, wenn es verfügbar ist.
- Ja, ich denke, das ist die intelligentere nennen (obwohl ich denke, ein bisschen mehr über das ob, das würde tatsächlich dazu führen, eine race-condition). Auch: wie es ist, ich glaube nicht, dass dies funktionieren wird, da nichts tatsächlich beginnt das Zuschauen des Streams. Sollte das getan werden, dass der Konstruktor?
- Ja, das ist genau das wo es sein soll. Sachliche Fehler.
- Sieht mir Recht jetzt. +1!
InformationsquelleAutor Aaronaught
2

Ja, das kann getan werden. Verwenden Sie den non-blocking Stream.BeginRead - Methode mit einem Generalasyncdelegate. Der Rückruf wird asynchron aufgerufen, sobald Daten verfügbar. In der callback, call Stream.EndRead, um die Daten abzurufen, und rufen Sie Stream.BeginRead wieder, um das nächste Segment der Daten. Puffer für eingehende Daten in ein byte-array, das groß genug ist, halten Sie die Nachricht. Sobald das byte-array voll ist (mehrere callback-Aufrufe benötigt werden könnten), das Ereignis auslösen. Lesen Sie dann die nächste Nachricht, die Größe, erstellen Sie einen neuen Puffer, wiederholen, fertig.
- Er sagte, dass ohne die Verwendung von threads!!! =)
- Ungleichzeitigkeiten ist multithreading. Dieses problem ist inhärent man von multithreading. Ich vermute, was der OP bedeutet, dass er nicht explizit erstellen des threads selbst.
- Ich nehme an, der OP ist auf der Suche nach einer Lösung, die nicht explizit einen neuen Thread erstellen und nutzt die blockierende Read-Methode, aber für eine nicht-blockierende, asynchrone Lösung. Sie können keine Asynchronität mit keine threads.
- Ich verstehe, was du sagst, aber OP hat nicht erwähnt, ob Thread oder threading! =) Lass ihn verstehen, und wählen Sie.
- Er sagte: "ohne die Verwendung von Threads direkt", mit einem großen "T" zu Booten!
InformationsquelleAutor dtb
1

Dem normalen Ansatz ist die Verwendung der .NETTO-asynchrone Programmierung-Muster ausgesetzt Stream. Im wesentlichen, Sie beginnen, Lesen asynchron aufrufen Stream.BeginRead übergibt eine byte[] Puffer und eine callback-Methode wird aufgerufen, wenn die Daten aus dem stream gelesen. In der callback-Methode, rufen Sie Stream.EndRead auf, übergeben Sie die IAsncResult argument, das gegeben wurde, um Ihren Rückruf. Der Rückgabewert von EndRead sagt Ihnen, wie viele bytes in den Puffer eingelesen.

Sobald Sie habe die ersten paar bytes auf diese Weise können Sie dann warten, bis der rest der Nachricht (wenn Sie nicht genug bekommen Daten das erste mal), indem Sie BeginRead wieder. Sobald Sie haben die gesamte Meldung können Sie das Ereignis auslösen.

InformationsquelleAutor Will Vousden
1

Nicht mit Strom.BeginRead() das gleiche wie mit dem synchron-Stream.Read () - Methode in einem separaten thread?

InformationsquelleAutor user361633

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.