Gibt es eine Sperrstream, Textreader oder String in .NET?

Question

Ich möchte eine Hintergrundaufgabe auszuführen, die eine Eingabe von einem Textreader liest und verarbeitet es zu einem Zeitpunkt, eine Linie. Ich mag die Hintergrundaufgabe, bis der Benutzer tippt einen Text in ein Feld blockieren und klickt auf die Absenden-Button. Gibt es einen Geschmack von Textreader, die blockiert, bis Text zur Verfügung steht und lassen Sie irgendwie mehr Text auf die zugrunde liegende Quelle hinzufügen?

Ich dachte, dass ein Stream und Stream auf den gleichen Memory zeigen könnte funktionieren, aber es scheint nicht zu. Der Stream sieht, dass die Memorystream zu Beginn leer ist, und nie überprüft erneut.

Ich weiß, dass es einfacher wäre, eine Process () -Methode zu schreiben und es nennen, wenn der Benutzer auf die Schaltfläche zum Senden klickt. Aber ich versuche, eine Plug-in-Architektur zu entwerfen, und ich würde die Plug-In wie wie altmodischen Konsolenanwendungen mit einem Eingangsstrom und einem Ausgangsstrom zu suchen. Ich mag den Eingangsstrom der Plug-in nur blockieren, bis der Benutzer den Knopf mit einigem Eingabetext zum Senden klickt.

Answer 1

Es scheint, dass es keine Umsetzung dieser ist - die seltsam ist, da ich darüber einig, dass es ein nützliches Konstrukt wäre. Aber es sollte einfach sein, zu schreiben. So etwas sollte funktionieren:

  public class BlockingStream: Stream
  {
    private readonly Stream _stream;

    public BlockingStream(Stream stream)
    {
      if(!stream.CanSeek)
        throw new ArgumentException("Stream must support seek", "stream");
      _stream = stream;
    }

    public override void Flush()
    {
      lock (_stream)
      {
        _stream.Flush();
        Monitor.Pulse(_stream);
      }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
      lock (_stream)
      {
        long res = _stream.Seek(offset, origin);
        Monitor.Pulse(_stream);
        return res;
      }
    }

    public override void SetLength(long value)
    {
      lock (_stream)
      {
        _stream.SetLength(value);
        Monitor.Pulse(_stream);
      }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
      lock (_stream)
      {
        do
        {
          int read = _stream.Read(buffer, offset, count);
          if (read > 0)
            return read;
          Monitor.Wait(_stream);
        } while (true);
      }
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
      lock (_stream)
      {
        long currentPosition = _stream.Position;
        _stream.Position = _stream.Length;
        _stream.Write(buffer, offset, count);
        _stream.Position = currentPosition;
        Monitor.Pulse(_stream);
      }
    }

    public override bool CanRead
    {
      get
      {
        lock (_stream)
        {
          return _stream.CanRead;
        }
      }
    }

    public override bool CanSeek
    {
      get
      {
        lock (_stream)
        {
          return _stream.CanSeek;
        }
      }
    }

    public override bool CanWrite
    {
      get
      {
        lock (_stream)
        {
          return _stream.CanWrite;
        }
      }
    }

    public override long Length
    {
      get
      {
        lock (_stream)
        {
          return _stream.Length;
        }
      }
    }

    public override long Position
    {
      get
      {
        lock (_stream)
        {
          return _stream.Position;
        }
      }
      set
      {
        lock (_stream)
        {
          _stream.Position = value;
          Monitor.Pulse(_stream);
        }
      }
    }
  }

Answer 2

Ich glaube, Sie würden viel besser ein Ereignis in Ihrer Haupt-Anwendung erstellen, die ausgelöst wird, wenn der Benutzer Treffer Senden. Die Textdaten würden in dem Ereignisse args übergeben werden. Jedes Plugin einen Event-Handler für das Ereignis und verarbeitet die übergebenen Daten in, wenn das Ereignis ausgelöst wird. Auf diese Weise können viele Plugins ohne viel Klempnerarbeiten auf Ihrer Seite, die Daten aus einer einzigen Vorlage bearbeiten, und bedeutet, dass die Plug-ins sind in der Lage, nur untätig herumsitzen, bis das Ereignis ausgelöst wird.