WinGUp der coole Updater von Notpad++

wingup ist ein Fork von gup4win/wingup von Don HO dem Programmier von Notepap++ auf GitHub. Es ist der automatische Update-Downloader von Notepad++. Notepad++ fand ich schon immer ziemlich gut und den automatischen Download, das anschließende automatische startet des neuen Setups ist eine schicke Lösung, die unkompliziert und einfach ist.
Deswegen wollte ich den dahinter stehenden Mechanismus gerne für eigene Software nutzen (LogMonitor und ComMonitor). Diese beiden Programme sind aber nicht in C++ geschrieben wie Notepad++ sondern es handelt sich um Wpf bzw. .Net Programme. Dadurch waren einige Änderungen nötig. WinGUp führt im Prinzip 4 Aktionen aus:

• Es prüft ob eine neuere Version der Software – auf einer bestimmten Quelle im Internet – vorhanden ist und wenn das der Fall ist, dann:
• lädt es das neue Setup herunter
• schließt die aktuelle laufende Software
• und starte anschließend das neue Setup

das Beenden der aktuelle laufende Software funktioniert bei Notpad++ über die registrierte Windows Klasse der Win32 Api. Unter .Net funktioniert das nicht. Aus diesem Grund habe ich WinGUp so geändert das es nach dem Text in der Titelleiste der Anwendung sucht z.B. LogMonitor_ und dann dieses Fenster schließt. Alles andere funktioniert so wie auch bei Notpad++. Für eventuell vorkommende Leerzeichen wird ein _ gesetzt, das dann später getauscht wird.

Den Fork findet man auf GitHub

MySimpleCsvConsoleAppCpp

ist ein C++ Konsolen-Programm das mit VS 2017 erstellt wurde. Es kann neben farbigen Ausgaben in der Windows-Konsole eine Csv Datei mit doubles (als Strings) einlesen und in eine Liste (list<string>) laden oder eine Csv mit random doubles erstellen und zurück in eine Datei schreiben.

Zu bemerken wäre, dass die MyCsvClass nicht sicher programmiert ist. Gemeint ist das sie keine Exceptions wirft oder abfängt. Wird ihr eine Csv-Datei vorgesetzt die sich nicht verarbeiten lässt (kein „;“ als Seperator, keine doubles als Inhalt etc.) kann die Anwendung abstürzt.

Folgende Features werden gezeigt:

• Farbige Ausgabe in einer Konsole für eine C++ Windows Anwendung
• Lesen und schreiben in einer Text Datei mit C/C++
• Csv Datei in C/C++ verarbeiten

Das Projekt auf Github.

Hinweis zum kompilieren ist das Windows 10 SDK notwendig. Der Download ist hier.

MyKillWinAppCpp

ist eine MFC C++ Anwendung, die alle Fenster auf dem Desktop durch iteriert und in einer ComboBox speichert. Wählt man einen Eintrag aus der ComboBox aus wird dieser in das Edit Feld geladen, so dass man es editieren kann wenn man es möchte um dann die Anwendung (das Fenster) mit dem Inhalt in dem Fenster Rahmen zu beenden:

Dies ist eigentlich ein WPF und .Net Blog, gelegentlich gibt es aber Ausnahmen, wie diese. Der Grund hierfür war das kleine ComMonitor Projekt. In dem ich die Software aus dem Internet updaten wollte wenn es eine neue Version gibt. So wie bei Notpad++, dessen Mechanismus ich auch mit freundlicher Genehmigung von Don Ho benutze (WinGup). WinGup hat nur einen kleinen Nachteil für WPF Anwendungen. Es schließt die upzudatende Anwendung auf Grund der unter Win32 registrierten Fenster-Klasse (RegisterClassEx). Die gibt es aber bei .Net Anwendungen so nicht. Deshalb muss man das Programm so ändern, das es auch für WPF Anwendungen brauchbar ist. Ich habe mich dazu entschlossen nach der Titelzeile im Fenster zu suchen und so das Fenster zu schließen. Eine nicht ganz ungefährliche Methode aber bis jetzt hatte ich keine bessere Idee. Nach den Äderungen in WinGup entschloss ich das Ganze in ein eigenes, kleines, „sauberes“ Demo-Projekt zu packen.

Folgende Features werden gezeigt:

• Beispiel für Win32 EnumWindows
• Beispiel für eine MFC C++ Dialog Applikation

Das Projekt gibt’s hier.

MyStructStreamConsoleAppCpp

wie MyStructStreamConsoleApp konvertiert das Programm einen Struct in einen Byte-Stream und wieder zurück in einen Struct, nur das Ganze in C++ und nicht in C#. Auch hier muss man dem Compiler sagen wie die Bytes ausgerichtet werden:

der C++ Compiler füllt die Zwischen-Bytes mit 0xCC auf im Gegensatz zum C# Compiler der sie mit 0x00 auffüllt:

Zu bemerken währe vielleicht noch das man in C++ solche „schicken Ausdrücke“ wie:

 
 public static T Convert<T>(byte[] data)
     where T : struct
 {
     int size = Marshal.SizeOf(typeof(T));
     IntPtr ptr = Marshal.AllocHGlobal(size);
     Marshal.Copy(data, 0, ptr, size);
     var result = (T)Marshal.PtrToStructure(ptr, typeof(T));
     Marshal.FreeHGlobal(ptr);

     return result;
 }

(C#)

nicht braucht sondern das einfach so machen kann:

    TI2 = (TypesI*)&bstream1;

(C++)

wo bei man sich im klaren sein muss das dies nicht das Selbe ist. Im oberen Fall wird eine Kopie angelegt, im unteren Fall zeigt der Pointer *TI2 auf den Byte-Stream bstream1.

Folgende Features werden gezeigt:

Structs in Byte-Streams konvertieren und wieder zurück in C++
Einen Byte-Stream in eine Datei schreiben C++

Das Projekt auf Github

Win32 Dll Aufruf in MyCSDllCall

wie im vorhergehenden Beitrag angekündigt werden in diesem Projekt die C und C++ Funktionen und Methoden aus einem .Net Programm heraus aufgerufen, die in dem Projekt MyCPPDllCall erstellt wurden. Ich habe das Programm MyCSDllCall.exe so geschrieben das es sich in der Ausgabe von MyCPPDllCall.exe exakt deckt:

Ein Wort ist zu dem Aufruf der C++ Methoden in MyCPPDll.dll zu bemerken. Nach meinem Kenntnisstand ist es nicht möglich Instanzen von native C++ Klassen in manged Code zu erzeugen. Aus diesem Grund sind die Funktionen:

    // Methods for using in managed code
    //
    // ClassICrate
    MyCPPDll::ClassI* ClassICrate()
    {
        return new MyCPPDll::ClassI();
    }

    // ClassIGetVersion
    char* ClassIGetVersion(MyCPPDll::ClassI* pClassI)
    {
        return pClassI->GetVersion();
    }

    // ClassIDelete
    void ClassIDelete(MyCPPDll::ClassI* pClassI)
    {
        delete pClassI;
    }

in MyCPPDll.cpp erstellt worden um die Methoden der Klasse ClassI in .Net zu nutzen:

    // MyCPPDll.dll
    Console.WriteLine("The version of MyCPPDll.dll (C++ classes) is:");
    IntPtr obj = Win32Wrapper.ClassICrate();

    IntPtr pString = Win32Wrapper.ClassIGetVersion(obj);
    string Version = Marshal.PtrToStringAnsi(pString);
    Console.WriteLine(Version);
    Console.WriteLine();

    Win32Wrapper.ClassIDelete(obj);

leider etwas umständlich, aber nicht anders zu realisieren.

Folgende Features werden gezeigt:

• Calling Win32 Dlls in .Net
• Calling C++ Methods in .Net

Das Projekt auf Github.

MyCPPDllCall

Öfter kommt es vor das man aus C# Programmen, Funktionen aus einer Win32 Dlls oder aus C oder C++ Dlls heraus aufrufen muss.

Wie man es machen kann zeige ich beim nächsten Beitrag. In diesem Beitrag möchte ich mit einem C++ Projekten anfangen, ein einfaches Konsole-Programm (MyCPPDllCall.exe) ruft einmal eine Methode aus einer C++ Klasse auf die in einer externen Dll (MyCPPDll.dll) liegt und einmal werden C-Funktionen aus einer anderen Dll (MyCDll.dll) aufgerufen.

Die selben Funktionen werden wir im nächsten Projekt aus einem C# Programm heraus aufrufen.
Damit man die Ausgabe besser erkennen kann habe ich es bunt gemacht.

Zu beachten ist das man die Header der Dlls in dem Exe-Projekt angibt:

Und der Linker braucht ebenfalls die Verweise:

Folgende Features werden gezeigt:

• Aufruf von C++ Klassen aus einem Exe heraus
• Aufruf von C Funktionen aus einem Exe heraus

 

Das Projekt auf Github.