Blog

Ich habe gerade nen Anwendungsfall da müssen sich auf nem Rechner zwei Applikationen austauschen.
Microsoft hat dafür die Named Pipes oder die Anonymous Pipes.

Die Anonymous Pipes haben paar Nachteile, diese hab ich dann mal nicht verwendet:

• Bidirektional nicht möglich (InOut)
• Async nicht möglich

Stackoverflow & Google hat irgendwie nicht das passende für mich, somit hab ich mir mal ne kleine Klasse geschrieben welche mir dann den Server & Client bereitstellt. Derzeit geht das dann nur lokal und nicht mit einem Netzwerkprozess. Aber ggf. pass ich das noch an. Angewendet wird das ganze wie folgt:

var pipeServer = new PipeBidirectional(PipeType.Server);
pipeServer.PipeMessage += PipeServerOnPipeMessage;
pipeServer.Start("MyPipe";
pipeServer.ListenAsync();
pipeServer.WriteAsync("Hello from Server");

private void PipeServerOnPipeMessage(string args)
{
  // Do stuff
}

var pipeClient = new PipeBidirectional(PipeType.Client);
pipeClient.PipeMessage += PipeServerOnPipeMessage;
pipeClient.Start("MyPipe");
pipeClient.ListenAsync();
pipeClient.WriteAsync("Hello from Client");

private static void PipeServerOnPipeMessage(string args)
{
  // Do stuff
}

using System;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;

namespace Suplanus.NamedPipes
{
  public class PipeBidirectional : IDisposable
  {
    public int MaxNumberOfServerInstances { get; set; } = 1;
    public int InBufferSize { get; set; } = 4096;
    public int OutBufferSize { get; set; } = 4096;

    public event DelegateMessage PipeMessage;

    private readonly PipeType _pipeType;
    private NamedPipeServerStream _serverPipe;
    private NamedPipeClientStream _clientPipe;
    private Process _clientProcess;
    private StreamWriter _streamWriter;
    private StreamReader _streamReader;

    public PipeBidirectional(PipeType pipeType)
    {
      _pipeType = pipeType;
    }

    public void Start(string pipeName, string clientProcessPath = null)
    {
      switch (_pipeType)
      {
        case PipeType.Server:
          _serverPipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut,
                                                  MaxNumberOfServerInstances,
                                                  PipeTransmissionMode.Message, PipeOptions.Asynchronous, InBufferSize,
                                                  OutBufferSize);

          // Start client process
          if (!string.IsNullOrEmpty(clientProcessPath))
          {
            _clientProcess = Process.GetProcesses()
                                    .FirstOrDefault(obj => clientProcessPath.Contains(obj.ProcessName) &&
                                                           obj.MainModule != null &&
                                                           obj.MainModule.FileName.Equals(clientProcessPath));
            if (_clientProcess == null)
            {
              _clientProcess = Process.Start(new ProcessStartInfo
              {
                CreateNoWindow = true,
                FileName = clientProcessPath,
                UseShellExecute = false,
              });
            }
          }
      
          // Start server
          _serverPipe.WaitForConnection();
          _streamWriter = new StreamWriter(_serverPipe);
          _streamWriter.AutoFlush = true;
          _streamReader = new StreamReader(_serverPipe);
          break;

        // Start client
        case PipeType.Client:
          _clientPipe = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut,
                                                  PipeOptions.Asynchronous);
          _clientPipe.Connect();
          _streamWriter = new StreamWriter(_clientPipe);
          _streamWriter.AutoFlush = true;
          _streamReader = new StreamReader(_clientPipe);
          break;
      }
    }

    public async void ListenAsync()
    {
      do
      {
        if (_streamReader != null)
        {
          string line = await _streamReader.ReadLineAsync();
          if (!string.IsNullOrEmpty(line))
          {
            PipeMessage?.Invoke(line);
          }
        }
      }
      while (true);

      // ReSharper disable once FunctionNeverReturns
    }

    public async void WriteAsync(string message)
    {
      await _streamWriter.WriteLineAsync(message);
    }

    public void Dispose()
    {
      _streamWriter?.Dispose();
      _streamReader?.Dispose();

      if (_serverPipe != null && _serverPipe.IsConnected)
      {
        _serverPipe?.Disconnect();  
      }
      
      _serverPipe?.Dispose();
      _clientPipe?.Dispose();
      _clientProcess?.Kill();
      _clientProcess?.Dispose();
    }
  }

  public delegate void DelegateMessage(string args);
}

Ich hab das hier mal als Gist gespeichert. Paar Sachen sind noch nicht so schön, wie z.B. dass der optionale Process einfach so gekillt wird. Hier könnte man diese per Message einfach schön runterfahren. In meinem Fall ist das aber so OK 🦄