Wie mache ich das denn?

    public partial class App : Application
    {
        private static readonly log4net.ILog Logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        private void App_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            Logger.Fatal(e.Exception);
            e.Handled = true;
        }
    }

funktioniert nicht....Ich habe bisher keine App Klasse gehabt und habe mich nur um das MainWindow gekümmert.

Ich habe das Problem, dass ich seit heute auf einer Maschine mit meiner WPF Applikation bei einem bestimmten Click immer einen Crash habe.
Auf anderen Maschinen läuft es und den Crash gab es gestern mit dem gleichen Code auf besagter Maschine auch nicht.
Der Stack-Trace im Event Log ist auch nicht aufschlussreich.

Fehlermeldung:
<Data>Application: xxx.exe Framework Version: v4.0.30319 Description: The process was terminated due to an unhandled exception. Exception Info: System.ApplicationException at DynamicClass.ExceptionHelper(System.Object) at System.Threading.ThreadHelper.ThreadStart_Context(System.Object) at System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean) at System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean) at System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object) at System.Threading.ThreadHelper.ThreadStart(System.Object)

Mit viel Logging sehe ich auch nicht viel - hat jemand von Euch eine Idee, was ich machen sollte?

2 Tips noch:

1. In C# gibt es genauso wie in C++ den sizeof Operator.
   Ich würde mittels zwei kleiner Testprogramme vergleichen, dass die Länge übereinstimmen. Unter Umständen gibt es noch Alignment Probleme, die Du so findest.

2.) Bei einem Callback musst Du aufpassen, dass Du mit einer statischen Variable für das Delegate im Managed Bereich arbeiten musst, damit der Callback nicht vom Garbage Collector nach dem Ende der Methode weggeräumt wird. Der Garbage Collector zählt nur Referenzen im Managed Bereich und denkt sonst, dass die Funktionsreferenz nicht mehr gebraucht wird. Das ist ein typisches Problem, was man oft erst in Produktion merkt ,wenn dann nach x Aufrufen auf einmal alles zusammenbricht.

Schau Dir mal den Artikel an.
Es kommt auch ein bisschen darauf an, ob Du nur lesen oder auch schreiben musst.
Wenn Du nur lesen musst, dann würde ich einfach einen IntPtr nehmen und dann eine Funktion zum Auspacken bauen.

Wenn Du bereit bist unsafe zu nehmen, dann würde ich

 public fixed char szAccess[2];

nehmen.
Wenn Du auf unsafe verzichten möchtest, dann würde ich

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte szAccess[2]; 

benutzen.

In Java gibt es keine Delegates/Events - da musst Du dann den Observer als eigenständige Klasse implementieren und da gebe ich Deinem Freund recht, daß dort sich der Aufwand nicht immer lohnt. In C# ist das anders.

Die moderne Alternative zu Events sind die Reactive Extensions.
Intro To Rx ist eine tolle Webseite dazu.

Es gibt verschiedene Arten von Proxies - siehe zum Beispiel bei Wikipedia.
SOCKS5 kannst Du z.B. nicht direkt mit WebRequest ansprechen. Finde erstmal genau Deinen Proxy Typ raus und schaue nach, ob das tatsächlich unterstützt ist.

Ich habe eher das Gefühl, daß Du mit der Datei eine Art Logging machen willst.
Würde an Deiner Stelle mal anschauen, ob es nicht einfacher wäre, daß Du log4Net, NLog oder etwas anderes nimmst.

random number generator with no duplicates

HashSet<int> numbers = new HashSet<int>();
while (numbers.Count < 6) {
    numbers.Add(random.Next(1, 49));
}

ist die einfachste Lösung davon.

Fehlt ein Flush?
Ansonsten würde ich mir das mit WireShark anschauen.

Würde an sich immer eine eigene Klasse erstellen, da man nie weiss, ob nicht noch mehr Spalten kommen.
Wenn Du das nicht willst, dann musst Du mit object arbeiten, daß float wird dann mittels Boxing in eine Referent umgewandelt.

Ein Float ist ein Struct/Werttyp, keine Klasse/Referenz - deswegen kannst Du nicht binden.

Erstmal solltest Du Dich mehr mit Deinen fachlichen Anforderungen beschäftigen.
MathDotNet oder Accord.NET sind ein paar ganz interessante freie Bibliotheken.

Ich benutze gerne PropertyChanged.Fody. Die Doku findest Du unter Github.

Dann brauchst Du nur ein

[ImplementPropertyChanged]

vor die Klasse setzen und jede public Property implementiert dann INotifyPropertyChanged automatisch...

Ich würde mir an Deiner Stelle Aeron.NET anschauen. Das ist eine recht interessante Middleware, die auch mit Shared Memory funktioniert.

Ich würde mir WriteableBitmapEx anschauen - ob die Bibliothek für Dich passt, musst Du selber ausprobieren - aber das gibt Dir auf jeden Fall Denkanstösse.

Du kannst mit dem Fiddler auch HTTPS mitschneiden - das Vorgehen wird hier vorgestellt.

Ich würde mittels Fiddler vergleichen, welche Daten via dem Scratchpad und via Deiner Applikation gesendet werden.

Ich würde an Deiner Stelle erstmal klein anfangen, indem Du Azure als Backup-Lösung einsetzt. Wenn Du vieles redundant hast, dann kannst Du da echtes Geld sparen, da Du nix mehr redundant brauchst.
Bei der Azure-Roadshow ist mir bewusst geworden, dass die hybride Cloud der beste Einstieg ist. Bei mir ist das recht einfach, weil man über Azure nun Cisco Site to Site bekommen kann.

Wie wäre es mit einem lokalen DNS Server?
Das wäre die saubere Variante?

Aforge ist schon seit mehr als 2 Jahren nicht mehr aktualisiert worden.
Ich würde mir da eher so etwas wie OpenCV via Emgu anschauen.
Vielleicht gibt es auch Möglichkeiten mit GPU/Cuda.

Zwei Anmerkungen dazu:Die Unterstützung des Binary Serializer in DotNet Core ist zur Zeit ein offenes Issue. Binary Serializer ist langsamer als z.B. ProtocolBuffers oder MS Bond und vor allem werden keine nicht verschiedenen Versionen unterstützt - d.h. ein zusätzliches Feld macht die Dateien unbrauchbar. Deswegen würde ich davon die Finger lassen.

Die saubere Lösung ist es immer eine Ping Nachricht in das Protokoll einzubauen, die der Server alle x Sekunden schickt und die der Client dann in y Sekunde beantworten muss - Firewalls kappen gerne Verbindungen bei Inaktivität und hängende Clients möchte man auch lieber abhängen.
Exceptions gibt es nur, wenn der Client sich unsauber beendet - beim Ziehen eines Netzwerkkabels zum Beispiel sieht man nix.

Ich würde einiges anderes machen, wenn ich Dich richtig verstanden habe.
Erstmal solltest Du nur mit einer Instanz/Singleton arbeiten, um Synchronisationsprobleme zu vermeiden, damit gleichzeitiges Senden funktioniert.
Dann würde ich mir überlegen, ob Du beim Senden das delegate oder den EventHandler mitgeben möchtest oder nicht.
Intern würde ich auf jeden Fall eine Sequenz-Nummer mitgeben, wenn es geht, so daß Du Request und Response miteinander verknüpfen kannst - auch bei der Fehlersuche hilft Dir das. Das halte ich für ein sauberes Vorgehen.

Ich habe das ganze nicht so 100 % verstanden - aber gefühlt solltest Du nicht mit Listen, sondern mit einem Dictionary arbeiten.
Die Position ist dabei der Key. Wenn Du dann Deinen Ball bewegst, dann musst Du prüfen, ob entweder der Key, der neuen Position schon vorhanden ist oder nicht. Wenn ja, dann entfernst Du den Ball und das Objekt an der Stelle des neuen Key oder wenn nicht entfernst Du nur den alten Key und fügst das Ball mit dem neuen Key wieder hinzu.

Kapsle alle Zugriffe auf die Datenbank in einem eigenen Service.
Würde nicht bei einem Neu-Design die WPF-App mit der Datenbank sprechen lassen.
Wenn Du performante Serialisierung wie Protocol Buffers nimmst, dann hast Du kein Performance Problem - einen schönen Benchmark findest Du hier.

Für das WPF Design würde ich Dir mahapps und dragablz empfehlen - das sind sehr schöne GUI Kits, um eine moderne Oberfläche zu erstellen.

Schwer zu sagen was schief geht - an Deiner Stelle würde ich den Mischmasch zwischen nativen Strukturen und .NET/CLR Strukturen aufbrechen, so daß Du einen klaren Schnitt machen kannst.
Da es um ein GUI geht, sollte das bei der Performance nicht wehtun, aber dann hast Du eine klare Idee, wo es schiefgeht.

Du musst natürlich das Free aufrufen - der klassische C# Weg ist, daß Du für die Strukturen IDisposable definierst und dann die Strukturen entsprechend freigibst, wenn das aufgerufen wird.
Structs sind Wertetypen - bei Dir benutzt Du die Properties wieder - das schafft Komplexität.

Wenn Du das machst, dann kannst Du schönen Code schreiben:

using (UnmanagedType t =new UnmanagedType()) 
{
    byte charset = t.GdiCharSet;
}

In dem Fall wird das Dispose dann mit dem Ende des Blocks automatisch aufgerufen und der Compiler hilft Dir, nicht nach dem Dispose etwas mit der Variable zu machen.

Wie Coffeebean es sagt - Deine Datenstruktur muss zu Deinen funktionalen Anforderungen an Deine Applikation passen.
Der XML Serializer macht dann die Arbeit automatisch.
Die menschliche Lesbarkeit von XML ist ein altbekanntes Problem - deswegen wird es auch immer mehr von JSON und anderen Formatten verdrängt.

Du verwechselst wahrscheinlich RecordCount mit FieldCount....
Aber an sich brauchst Du das gar nicht. Du machst das doppelt.

private string[] getDataFromPublic()
{
            String conString = "SERVER=127.0.0.1;DATABASE=lss_software;UID=root;";
            MySqlConnection con = new MySqlConnection(conString);
            MySqlCommand com = con.CreateCommand();
            com.CommandText = "select licenseKey, active from license";
            MySqlDataReader reader;
            con.Open();
            reader = com.ExecuteReader();
            string[] data = new string[reader.FieldCount];
            int i = 0;
            MessageBox.Show(Convert.ToString(reader.RecordCount ));
            while (reader.Read())
            {
                MessageBox.Show(reader.GetValue(i).ToString());
                data[i] = reader.GetValue(i).ToString();
                i++;
            }
            return data;
}

Bitte sei etwas präziser mit Codebeispiel.
Wahrscheinlich hast Du ein implizites ToString() in Deinem Code mit dem TextWriter.

Die Klassifizierung von Bildern ist ein klassisches Machine Learning Problem.
Im ersten Kapitel von "Machine Learning Projects for .NET developers" wird so ein Problem diskutiert. Da geht es sogar um Handschriften-Erkennung.
Die Azure Lösung wäre das computer vision api

Dafür gibt es das Schlüsselwort sealed.

Zeig uns, was Du konkret machst. Wenn Du nur Marshal.PtrToStructure machst, dann ist nix nötig.
Der Garbage Collector macht seine Arbeit für alles, was im Managed Bereich ist, automatisch.
Da der Garbage Collector nicht weiss, was im Unmanaged Bereich passiert, muss man bei Function Pointer/Delegates künstliche Referenzen halten, damit der Garbage Collector die nicht wegräumt, obwohl man sie noch braucht.

Du solltest eine Klasse haben, die alle Spalten zur Verfügung stellt.
Du kannst dann zum Beispiel die Instanzen der Klasse im Konstruktor mit allen DataTables instanzieren. Das ist sauber und nachvollziehbar.
Gerade wildes XAML Binding führt zu Spaghetti-Code.

Ich habe etwas sehr einfaches mit Selfhosting damit gemacht und da hatte ich sehr schnell Ergebnisse.
Brauchte ein bisschen Routing und das wars.
Die Komplexität/Aufwand für das Einarbeiten hängt mehr von Deinen Wünschen/Anforderungen ab.

Eine einfache Alternative zu ASP.NET wäre Nancy.

Wird man ein guter Rennfahrer, weil man einen Motor bauen kann?

Wenn Du etwas richtig tiefgehendes lernen willst, dann würde ich Dir CLR Via C# empfehlen.
Da werden viele fundamentale Sachen erklärt.
Advanced .NET Debugging ist auch gut, nur leider etwas veraltet, es hat aber viele interessante Übungen.
Ansonsten würde ich mich mehr an die Specs halten, da ist der Schwerpunkt aber mehr auf präzise Beschreibung und weniger auf den Aufbau von Verständnis der Zusammenhänge.
Writing High-Performance .NET Code hat mir zuletzt gut gefallen - da werden auch einige fundamentale Dinge erklärt und mit praktischen Beispielen verknüpft.

Das es um Hardware-Treiber geht, könnte es anders sein, da ja die Hardware verkauft werden soll.
Ich würde einfach mal nachfragen.

Einen Tip habe ich noch.
Schreibe Dir kleine C und C# Programme, um mittels sizeof die Länge der C und C# Strukturen zu bekommen. sizeof gibt es auch in C#.
Das gibt Dir eine erste Indikation, ob Du alles richtig gemacht haben könntest.

Wenn Du C Strukturen nach C# umsetzt, dann würde ich mich immer an diese Tabelle ("Marshaling Arguments") orientieren.
Ausserdem würde ich nie herumkopieren mit Marshal.Copy, sondern immer einen quasi Cast mit Marshal.PtrToStructure machen. Der Code sieht dann im Regelfall so aus:

public static T FromBytes(byte[] bytes)
        {
            var handle = GCHandle.Alloc(bytes,
                                        GCHandleType.Pinned);
            var result = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(),
                                                        typeof (T));
            handle.Free();
            return result;
        }

Und RawData wird immer so aussehen:

  struct RAW_DATA
        {
            public uint dwDataLen;
            public IntPtrpData;
        }

Zum Thema Xamarin lohnt es sich Show 1276 von Dotnetrocks zu hören.

Ein Grund des Erfolgs von Xamarin ist, dass es nicht versucht erfolglos ein allgemeines GUI-Modell zu sein (wie z.B. Java Fx oder qt), sondern die nativen Eigenschaften der jeweiligen Plattform unterstützt.
So hat man dann am Ende 80-90 % gemeinsame Code Basis für alle Plattformen und 10 % speziellen Code.

Relative Pfade kann man schon in den Code hereinbauen....absolute natürlich nicht 😉

Wenn Du eine Konsole-Anwendung hast, dann ist die Konfiguration in foo.exe.config - nicht in app.config.
Beim Kompilieren wird app.config nach foo.exe.config kopiert. Vielleicht ist da etwas schief gelaufen.
Die Klassenbibliothek sollte keine eigene Konfiguration haben - das sollte alles an einem Platz sein, sonst wird das schnell unübersichtlich und unwartbar.

Die Kosten siehst für Xamarin siehst Du bei den Lizenzbedingungen.
Open Source und bis 5 Nutzer ist frei.
Ansonsten brauchst Du die Enterprise-Lizenz, ähnlich wie bei Visual Studio.

Man kann bei Xamarin einfach das Studio herunterladen. Man wird nach seiner Visual Studio Version gefragt.
Die Lizenzbedingungen erklären dann die jeweiligen Einschränkungen.

Einerseits würde ich Dir bei komplizierten BuildProzessen empfehlen, FAKE anzuschauen - da kommt Visual Studio an seine Grenzen.

Für reine Bit-Einstellungen kann man auch Corflags benutzen, um im nachhinein die Bit Version einzustellen - solange Du keinen speziellen Code mit Präprozessor #if hast, was ich brauche.

Es geht jedes Ubuntu UserMode binary. Also sollte auch zsh gehen.