C#

Cuterdio – 1.0

Meine App fürs Internetradio hören Radium wird leider nicht mehr weiterentwickelt.
Aus diesem Grund bin ich auf die Suche gegangen. Folgende Vorraussetzungen hatte ich:

  • MacOS & iOS
  • Coverart
  • Band & Titel Anzeige
  • Einfaches Userinterface

Leider (oder zum Glück) gab es so eine App nicht. Darum hab ich mich entschlossen selbst eine App zu schreiben. Gesagt getan (naja so schnell ging es nicht)…
Daraus entstand Cuterdio. Der Name setzt sich zusammen aus den Wörtern „cuter Radio“ und der Tatsache dass ich die Musik von Ronnie James Dio liebe.
Bei 99designs.com hab ich mir noch ein zuckersüßes Icon erstellen lassen und die App als erstes für iOS veröffentlicht. Läuft auf iPhone & iPad.

Mac folgt als nächstes. Dann wahrscheinlich Android. Ich will auch versuchen für tvOS das ganze zu bauen. Ist aber mit Xamarin nicht so einfach.
Dazu hab ich noch ne Website gebaut: cuterdio.com.

Features:

  • Coverart
  • Album Information
  • In Spotify anzeigen
  • Große Radio Sender Datenbank mit über 25000 Einträgen
  • Keine Werbung
  • Kein Login / Registrieren

Über Feedback & Bewertungen freue ich mich sehr. Anbei ein paar Impressionen:

Von |2019-12-10T08:03:58+01:002019-12-06|C#, Cuterdio, Projekte|

Alternative zu Fuslogvw Fusion++

EPLAN Signierung & Ich… eine traurige Geschichte…
Darum bin ich des öfteren gezwungen Fuslogvw zu nutzen um mal die Bindungen und das Laden der DLLs zu betrachten. Das Tool bzw. die UI ist einfach schlimm…

Als ich nun wieder Stunden mit Fuslogvw verbracht habe, suchte ich (erneut) nach einer Alternative. Und jetzt gibt es eine: Fusion++.
Frei, OpenSource, was will man mehr!

Von |2019-09-20T11:24:01+02:002019-09-20|C#, EPLAN|

NamedPipeStream InOut Async

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 🦄

Von |2019-08-28T08:11:19+02:002019-08-28|C#|

Syncfusion SfDataGrid groups state

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);
        }
      }
    }
  }
}
Von |2019-08-08T07:51:45+02:002019-08-07|C#|

API Showcase auf GitHub

Ich habe hier mal ein kleines Repo erstellt um verschiedene APIs zu zeigen.
Wie gewohnt mit fertigem Programmcode. Zusätzlich sind kleine Präsentationen enthalten um einen kleinen Überblick zu geben.

Derzeit sind enthalten:

  • EPLAN Scripting
  • EPLAN API
  • Siemens TIA Portal Openness

Also falls Jemand Interesse hat, einfach bei mir melden :^)

Von |2019-03-26T13:38:17+01:002019-03-26|C#, EPLAN, EPLAN-API, TIA Portal|