C#

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 🦄

Ich nutze sehr gerne das SfDataGrid von Syncfusion. Die Lizenz ist auch super für kleine Unternehmen.
Normalerweise sollte man mit MVVM nicht dazu gezwungen sein die ItemSource neu zu setzen. Es gibt aber ein paar Edgecases da ist es notwendig.

Leider geht dadurch der State vom DataGrid verloren. So werden Gruppen z.B. wieder eingeklappt.
Der super Support von Syncfusion hat mir bei meinem Vorhaben unterstützt. Für dieses Problem hab ich dann eine kleine Extension geschrieben.
Wichtig ist dass AutoExpandGroups = false; gesetzt ist, sonst werden immer alle Gruppen ausgeklappt.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Syncfusion.Data;
using Syncfusion.UI.Xaml.Grid;

namespace Suplanus.Test.Extension
{
  internal static class SfDataGridExtensions
  {
    public static void RebindTo(this SfDataGrid dataGrid, object itemSource)
    {
      // Save state
      List<Group> expandedGroups = new List<Group>();
      ReadOnlyObservableCollection<object> groups = dataGrid.View?.Groups;
      if (groups != null)
      {
        dataGrid.AutoExpandGroups = false;
        foreach (Group group in groups)
        {
          if (group.IsExpanded)
          {
            expandedGroups.Add(group);
          }
        }
      }

      // Rebind
      dataGrid.ItemsSource = null;
      dataGrid.ItemsSource = itemSource;

      // Set state
      if (dataGrid.View?.Groups != null)
      {
        foreach (Group group in dataGrid.View.Groups)
        {
          Group isExpandGroup = group;
          Group key = expandedGroups.FirstOrDefault(c => c.Key.ToString() == isExpandGroup.Key.ToString());
          do
          {
            if (key != null)
            {
              dataGrid.ExpandGroup(isExpandGroup);
            }

            if (isExpandGroup.Groups != null)
            {
              isExpandGroup = isExpandGroup.Groups[0];
              key = expandedGroups.FirstOrDefault(
                col => col.Groups[0].Key.ToString() == group.Groups[0].Key.ToString());
            }
            else
            {
              isExpandGroup = null;
            }
          }
          while (isExpandGroup != null);
        }
      }
    }
  }
}