Quick und Dirt habe ich mir das eher so vorgestellt:

                XDocument xdoc = new XDocument();
                xdoc.Declaration = new XDeclaration("1.0", "utf-8", "yes");

                XNamespace projectNS = "http://www.blablablubb";
                XNamespace projectXSD = "http://www.w3.org/2001/XMLSchema";
                XNamespace projectXSI = "http://www.w3.org/2001/XMLSchema-instance";

                XElement root = new XElement(projectNS + "Project");


                root.Add(new XAttribute(XNamespace.Xmlns + "xsd", projectXSD.NamespaceName));
                root.Add(new XAttribute(XNamespace.Xmlns + "xsi", projectXSI.NamespaceName));


XElement xElement1 = new XElement("xElement1");
                projectInformation.Add(new XAttribute("Attribut1", asdf1));
                projectInformation.Add(new XAttribute("Attribut2", "asdf2"));
                projectInformation.Add(new XAttribute("xmlns", "http://www.blablablubb"));
                root.Add(xElement1);

XElement xElement2 = new XElement("xElement2");
                projectInformation.Add(new XAttribute("Attribut1", asdf1));
                projectInformation.Add(new XAttribute("Attribut2", "asdf2"));
                projectInformation.Add(new XAttribute("xmlns", "http://www.blablablubb"));
                root.Add(xElement2);

Dienste laufen unter einem, bei der Installation des Dienstes angegeben, Account.
Neben einem expliziten Benutzer Account gibt es noch spezielle Windows-Dienst Konten (Service User Accounts (Windows))
Wenn dir also nicht bekannt ist unter welchem Benutzer der Dienst läuft weil du keinen angegeben hast, dann läuft dein Dienst vermutlich erstmal unter einem dieser drei. Meine Vermutung LocalSystem.
Das ist grundsätzlich erstmal ein recht eingeschränkter Account der nicht viel darf.

Man kann den Dienst auch noch nach der Installation einen anderen Account zuweisen:
Configure How a Service Is Started

Du mußt also den Dienst einfach nur in der Dienstverwaltung umkonfigurieren und einen Account zuweisen der Löschberechtigungen auf diese Verzeichnisse hat.

Die Frage ist nicht unter welchem Account du die Anwendung installierst sondern unter welchem Account der Windows-Service läuft.
Dieser Account braucht die notwendigen Berechtigungen zum löschen der gewünschten Verzeichnisse.

Ich kenne mich nicht mit Linq-to-Xml aus, aber ich stelle die Vermutung an das du den Elementen explizit den von dir definierten Standardnamespace http://www.blablablubb zuweisen mußt.
(Ich glaube das geht darüber das du dem neuen Element ein Attribut xmlns hinzufügst das den Wert http://www.blablablubb hat).

Das Problem kommt meiner Vermutung nach daher das die Elemente keinen Namespace haben und du aber einen Standardnamespace (xmlns="http://www.blablablubb") im XML definiert hast.
Effektiv sind die "xElement1" und "xElement2" in einem anderen Namespace als das "Project" Element.

Vermutlich ist das die Resource die aus der Exe gezogen hast nicht wirklich ein Icon sondern eher ein Bitmap (oder Jpg, oder Png etc.)
Du kannst ja mal probieren ob die Lösung auch bei dir funktioniert:
wpf - How do I get an Icon from a png image? - Stack Overflow

Wenn ja, würde das den Verdacht bestätigen.

Wie starte ich in einer laufenden Anwendung von außen durch VS die Methode?
Das erschließt sich mir nicht 😃

Aus VS heraus vielleicht nicht so ohne weiteres ... hier könnte ich mir nur vorstellen das "Direktfenster" zu benutzen. Oder eben an einem Haltepunkt im Quickwatch Fenster oder ähnliches ...

Wenn du in deinem Programm etwas auslösen willst was nicht eigentlich zum Programm gehört, dafür mußt du dir eben schon einen "Trigger" in dein Programm einbauen.
Wie dieser "Trigger" aussieht bleibt deiner Fantasie überlassen.
Ich habe mir in vielen Projekten so beholfen das ich eine Tastenkombination "mit einer Präprozessordirektive (DEBUG)" eingebaut die dann eine simple von mir programmierte Maske darstellte in der ich meine Testfunktion auswählen und die notwendigen Werte erfassen konnte.

Möchtest du uns mal ein konkretes Beispiel aufzeigen was du genau machen willst?
(Am besten mit Codeauszügen)

Was Abt meint:
Events sollten eigentlich keine große Logik beinhalten sondern nur idealerweise die gesamte Logik in eine unabhängig aufzurufende Methode auslagern.
Damit hättest du nicht die Anforderung das du irgendwelche Events auslösen müßtest sondern nur die Methoden die diese Events dann ebenso aufrufen. Stichwort: Testbarkeit und Unit-Tests.

Warum du die Ausführung nicht steuern könenn solltest wenn sie in einer anderen Methode lagert erschließt sich mir nicht.

Aber um deine eigentliche Frage zu beantworten.
EventHandler sind auch nur Methoden die du ebenso wie jede andere Methode einfach ausführen kannst.
Die Parameter kannst du, wenn du denn weißt welche kommen, ganz einfach selbst übergeben.
Manche Controls bieten auch Methoden an um ein UI Event zu generieren:
Der Button zum Beispiel hat die Button.PerformClick Method (System.Windows.Forms)
die ein Click Event auslöst.

Ja vermutlich hast du recht ...
Auch wieder nur Spekulation aber vermutlich liegt das Problem wirklich darin das du aus verschiedenen Threads heraus arbeitest.

Schau mal ob das hier hilft:
c# - How to Stop SpeakAsync if another message were about to speak out? - Stack Overflow

Nachtrag: 14.08.2015 22:32
Durch den folgenden Link bin ich noch auf die Idee gekommen:
Pause and Resume with the SpeechSynthesizer on Windows Phone 8 - frontendplay

Probier mal die Methode SpeechSynthesizer.SpeakSsmlAsync Method (System.Speech.Synthesis) zu verwenden.
Die liefert die ein Promp Objekt als Return Value das du wiederum in einer statischen Variable speichern kannst die du wiederum als Parameter für die Cancel Methode benutzen kannst um explizit diese Ausgabe zu stoppen. Erscheint zwar etwas umständlich aber wenn es wirklich an dem Threading Thema hängt kannst du das damit eingrenzen bzw. umgehen.

Hast du mal das Beispiel auf Initialize and Manage the Speech Synthesizer (Microsoft.Speech)
ausprobiert?

using System.Threading;

SpeechSynthesizer synth = new SpeechSynthesizer();

// Begin speaking the prompt.
synth.SpeakAsync("The weather forecast for today is partly cloudy with some sun breaks.");

// Speak for 1.5 seconds.
Thread.Sleep(1500);

// Pause the SpeechSynthesizer object for 1.5 seconds.
synth.Pause();
Thread.Sleep(1500);


// Resume speaking for 1.5 seconds.
synth.Resume();

// Cancel the current speak operation and all queued SpeakAsync operations.
synth.SpeakAsyncCancelAll();

Wenn das funktioniert kann man zumindest davon ausgehen das die Cancel Methode prinzipiell erst mal so funktioniert wie du dir vorstellst.

Ah verstehe ...
Hmmm fürchte da werde ich nur spekulieren können, aber das ist immer so eine Sache mit den Asynchronen Methoden.
Du hast keine sicheren Indikator wie schnell sie ausgeführt werden.

Schau mal ob es anstatt SpeakAsyncCancelAll eine synchrone Cancel Methode (SpeakCancelAll?) gibt.
Wenn ja probiere mal die anstatt die asynchrone. Erstmal nur zum Test ob das dein Problem löst.
Könnte mir vorstellen das der Cancel nicht schnell genug ausgeführt ...

Kann das Problem nach deiner Beschreibung nicht ganz verstehen ...
Das er den letzten Satz noch fertig spricht scheint mir dem geposteten Code nach vollkommen korrekt zu sein.
Zuerst stoppst du alle noch laufenden Sprachausgaben und dann startest du "Mich kriegt man nicht so schnell zum schweigen"
Warum sollte er diesen Satz nicht zu ende sprechen?

Soweit ich das auf die schnelle beurteilen kann ist dein Problem vermutlich das deine Variable "Bot" aus dem Scope läuft und vom Garbage Collector "aufgeräumt" wird.

Wie folgt sollte es besser funktionieren.

    class Program
    {

        private static FileSystemWatcher incoming;
        private static SpeechSynthesizer Bot = new SpeechSynthesizer();

        static void Main(string[] args)
        {
            Bot.SetOutputToDefaultAudioDevice();

            incoming = new FileSystemWatcher();
            incoming.Path = @"d:\Jasper";

...

Die Technik die ich meine gibt es schon lange und hat nichts mit der Projektart zu tun 😉
Der zweite Punkt auf der folgende Seite beschreibt was ich meine:
How to: Add Existing Items to a Project

Aber du hast insofern Recht als das es in den letzten Jahren ähnliche Arten der Verlinkung auf unterschiedlicher Ebene gibt (Shared Library ist eine davon)

Es gibt noch einen anderen Weg:
Verknüpfte Source Dateien.

Solange dein Quellcode wirklich nur von der Funktionalität gebrauch macht die in beiden Framework Typen (Normal und CF) vorkommt kannst du zwei verschiedene Klassenbibliothekenprojekte anlegen und die Quellcodedateien (*.cs) als verknüpfte Dateien einbinden.

Du hast im Endeffekt dann im Ergebnis weiterhin zwei verschiedene DLLs (eine für normale .NET Framework Clients und eine für CF.NET) aber die Codebasis teilst du in beiden und hast damit nicht den doppelten Aufwand des "aktuell haltens" und des Programmierens der gleichen Funktionalität).

Ich weiß nicht ob das überhaupt geht denn auf der Downloadseite steht:

This solution will not build because it is missing crucial components such as resources, XAML files, etc. but it will be sufficient to browse the source code inside Visual Studio.

Das heißt der Quellcode läßt sich nicht mal kompilieren.
Du müßtest also erstmal anfangen diese Projekte so zu bereinigen das sie sich überhaupt kompilieren lassen.

...
Dann sei gesagt, dass es kein VS2015 Express gibt.
Express Versionen sind seit 2013 abgeschafft und durch die Community Edition ersetzt worden.
...

Hmmm, ich weiß nicht ob das so stimmt:
Visual Studio Express
Ich war auch der Meinung das es kein Express mehr gäbe, aber scheinbar gibt es noch Platformspezifische VS Versionen die unter dem Label Express laufen.

Vermutlich steckt darin auch nur eine abgespeckte Community Edition, aber für den außenstehenden ist das nicht offensichtlich.

Na gut ... 😉
Dann halten wir Fest, T4 sollte nicht im Kontext von Snippets erwähnt werden 😉
Auch nicht "wenn es etwas mehr ist" 😉

Die Einsatzbereiche sind doch zu verschieden bei diesen beiden Technologien und eine Überlappung an möglichen Einsatzbereichen sehe ich auch nicht.

Soll nicht heißen das T4 oder Snippets schlecht sind.

Es gibt ein Event auf AppDomain Ebene:
AppDomain.AssemblyResolve Event
Dieses Event wird immer dann gefeuert wenn das Framework eine Assembly nicht findet.
In diesem Event kannst du deine eigene Ladelogik implementieren und das gewünschet Assembly zurückliefern.

Eine serialisierte Datei enthält NICHT die Assemblies.
Eine serialisierte Datei enthält nur die Informationen des Objektes das serialisiert worden ist.
Die Typinformationen hierfür befinden sich nachwievor in der Assembly und dazu wird auch die Assembly benötigt.

Eine Assembly ist im weitesten Sinne sowieso schon "serialisiert" mit anderen Worten eine Assembly enthält alle Typinformationen die du brauchst (bzw. das .NET Framework für die Serialisierung und Deserialisierung).
Warum willst du denn die Assemblies nicht mitliefern?

Im Zweifelsfall läßt du dir halt ein Pseudoserialisiertes Format einfallen wie z.B.
Das serialisierte Objekt als BIN Datei, die Assembly das die Typinformationen enthält, das zusammen in eine ZIP Datei.
Nun mußt du beim Deserialisieren eben zuerst die ZIP Datei entpacken und das BIN File deserialisieren und schon hast du was du erreichen willst.

In dem ersten von mir geposteten PDF ist ab Seite 73 die "Character Code Reference" drin.
Da findest du genau welches Zeichen in welcher Codepage durch welchen Hexwert abgebildet wird.
Damit solltest du das € finden können ohne zu raten 😉

Hmmm, ich weiß ja nicht, aber mir scheint ja das da was falsch läuft:

1. Dein PDF scheint veraltet zu sein. Es ist von 1996 und scheint nur für den TM-88 zu sein, nicht deren Nachfolger Modell II etc.
2. In meinem PDF ist der Befehl ESC T für die Codepage und in deinem Dokument ist es für die Druckrichtung
3. In meinem PDF ist der Befehl ESC T = \x1B \x74 (Nicht wie in deinem \x1B \x52)
4. Wenn 2 als Codepage (laut meinem PDF PC 850 (Multilingual) nicht funktioniert, probier mal die anderen Codepages wie zum Beispiel: 19 PC 858 (EURO))

Also genügend Dinge zum ausprobieren um das Problem weiter einzugrenzen 😉

Dachte mir schon das er das so gemeint hat, aber die Aussage:

Nur wofür bräuchte man so ein Snippet?

Wenn es mehr ist, kann da T4 helfen.

... könnte man falsch verstehen. Und zwar eben so das wenn man mehr von einem Snippet will das man als Ersatz T4 nehmen könnte.
Und das sehe ich eben nicht so (es sei denn weiterhin ich irre mich in der Hinsicht, was ich nicht ausschließen möchte 😃 ).
Klar kann T4 mehr, und ist ein mächtiges Werkzeug, aber soweit ich das Feature kenne nutzt es einem nichts wenn man es Projektübergreifend einsetzen will.
Genau das ist ja die Stärke von Snippets.
Das man ein kleines Stück Code Projektunabhängig jederzeit wiederverwenden kann.
Ein T4 funktioniert aber doch nur in einem Projekt ...

Also, um das Topic ein wenig zu erweitern, wenn es gestattet ist, wie würdet ihr denn die ursprüngliche Anforderung mit einem T4 lösen? Mir fällt da nämlich wirklich so auf die schnelle kein Weg ein als das T4 hier ein brauchbaren universellen Ansatz liefern würde der nicht mit viel Overhead verbunden wäre.
Versteht mich nicht falsch, mich interessiert das wirklich denn ich bin gerade was Snippets und T4 betrifft doch immer wieder hin und her gerissen...

Na da möchte ich aber wiedersprechen ...
Ein T4 Template ist zwar schön und gut aber ein Ersatz für den Einsatz eines Code Snippets ist das ja wohl nicht. (Alleine schon wie ich ein Snippet verwende, da kann ich nicht so einfach ein T4 Template reinbringen, oder kenne ich da wieder ein super-duper Feature nicht?)

Zumal das eben die Anforderung des Fragestellers auch nicht wirklich erfüllt, oder?

Ansonsten laße ich mich (und der Fragesteller sicherlich auch) gerne anhand des konkreten Beispiels (nach Anforderung siehe oben) vom Gegenteil überzeugen 😉

Da ich das Problem bis jetzt noch nicht hatte weiß ich nicht ob das hilft:
XAML editor won't render the controls in my WPF window

Hmmm, wenn ich mich richtig entsinne (ist schon ein Weilchen her das ich das gemacht habe)
könnte das mit dem eingestellten Zeichensatz des Druckers zusammen hängen.
Verwende den Befehl "ESC t" um den Zeichensatz zu aktivieren:
ESC-POS Befehlsreferenz (Seite 12)

Ich glaube das MorphieX einfach einen T-SQL Parser gebaut hat und nun eine möglichst große unterschiedliche Vielzahl an Select Statements sucht um möglichst sämtliche Aspekte seiner Implementation testen.

Daraus ergibt sich für mich:
Recht hat MorphieX das man für seine Anforderung nichts über irgendwelche Strukturen zu wissen braucht weil sein Parser ja nur Statements parsed. Dafür braucht man kein Hintergrundwissen über DB Details.
Ein Statement wie

Select [Ergebnis Spalte] AS Result from MeineTabelle WHERE Suchspalte1 IN (Select Keyfeld from [dbo].[Table] WHERE [Feld Gelöscht] = 0)

wäre meinem Verständnis schon die Erfüllung seiner Anfrage. Natürlich sucht er so etwas aber in Masse.

MorphiX' Anfrage macht aber nur bedingt Sinn meines Erachtens nach, weil Unit Testing so nicht funktioniert. Man kann sich zwar sicherer fühlen je mehr unterschiedliche Testdaten man hat, aber ich finde das man Implementationen modular testen sollte. Teile (Methoden) sollten für sich selbstständig getestet werden und funktionieren und hierfür benötigt man dann idealerweise nur kleinere Mengen an Testfällen um eben nur die möglichen Ablaufwege eines Teils (Methode) vollständig zu testen. "Code coverage" ist das Stichwort. Wer 100% Code coverage hat sollte sich sicher sein können das die Implementation alle Anforderungen zu 100% erfüllt und diese auch mit Unit Tests abdeckt.

Wenn du MorphiX aber diese Statements suchst um überhaupt herauszufinden welche Fälle alles auftreten können, so finde ich das dies der falsche Ansatz ist.
Wenn du einen vollständigen Parser bauen willst solltest du lieber die komplette Spezifikation abbilden (SELECT (t-SQL))
(Und das ist eine Menge ... 😉)

Ob es Sinn macht seinen eigenen T-SQL Parser zu implementieren ist eine andere Frage.
Willst einen Parser bauen weil du denkst es gibt nichts fertiges?
Oder weil alles was es gibt nicht deinen Anforderungen genügt?
Oder einfach zur Übung aus Spaß an der Freud'?

So würde das Beispiel von dir funktionieren.
In den Body der anonymem Methode (die als Action Parameter der Do Methode übergeben wird) kannst du reinschreiben was du willst.

Aber vermutlich habe ich immer noch nicht ganz verstanden welchen Umfang das ganze annehmen können soll oder wozu das ganze dienen soll.

public sealed class A
    {
        public void Do<T>(Action expression) 
        {
            // hier soll ToCall aufgerufen werden!!!
            expression.Invoke(); 
        }
    }

    public sealed class B
    {
        public void Method()
        {
            A test = new A();
            double dOut; // Beispiel 
            float fRef = 0f; // Beispiel 
            test.Do<B>(delegate() { ToCall<int>(1, 2, out dOut, ref fRef); });
        }

        private int ToCall<T>(int a, T b, out double c, ref float d)
        {
            c = 1.2d;
            d = 4.6f;
            return a + 1;
        }
    }

Verstehe nicht ganz wozu dieses A / B Klassen Konstrukt gut sein soll und warum du eine Expression verwendest.

Aber ein Weg wie es so funktioniert wie du es beschreibst:

public sealed class A
    {
        public void Do<T>(Action expression)
        {
            // hier soll ToCall aufgerufen werden!!!
            expression.Invoke();
        }
    }

    public sealed class B
    {
        public void Method()
        {
            A test = new A();
            test.Do<B>(ToCall);
        }

        private void ToCall()
        { }
    }

Das blinken der Drucker LED indiziert das Problem, soweit ich weiß.
Laut Technischer Referenz des Druckers könnte es sich bei dem Blink-Muster um einen CPU-Anweisungsfehler handeln:
PDF Technische Referenz

Das bedeutet wohl das der Drucker irgendwie nicht mit den Anweisungen klar kommt.

Ein weiteres Problem das ich kenne:
Wenn der Empfangspuffer des Druckers voll ist, verwirft der Drucker alle weiter eingehenden Anweisungen. Dies führt dann zu dem Verhalten der Drucker nur einen Teil der gesendeten Anweisungen verarbeitet und der Rest "verloren geht"
Hier mußt du mal prüfen wie groß der Empfangspuffer des Druckers ist (war glaube ich irgendwo bei 4kb oder so) und wie groß der Bitstream ist den du versuchst zu senden.

Wenn alles scheitert, den Drucker mal in den Debug Modus schalten (-> Handbuch des Druckers) und dann den Hexdump des Druckers mit den gesendeten Anweisungen vergleichen und sehen ob das wirklich alles stimmt.

Das Problem ist vermutlich nicht so schlimm wie du es empfindest.
Das Problem kommt eben aus dem Prinzip des Just-in-Time Compilings. Es werden eben nur die Dinge geladen die auch wirklich gebraucht werden deswegen ist ein Konzept wie "das Framework vollständig zu laden" eher unmöglich. Na gut nicht unmöglich ... aber vermutlich nicht sinnvoll.

Wenn dich die (Start-) Performance der Anwendungen derart beeinträchtigt solltest du vielleicht mit dem Gedanken spielen Native Images zu erzeugen.
Hierfür gibt es eben speziell das Tool "ngen"
Ngen.exe (Native Image Generator)

Mit diesen Native Images sollten die Anwendungen etwas performanter laufen (und starten evtl. auch).

Abgesehen dürften WPF Anwendungen gegenüber klassischen .NET Forms Anwendungen auch je nach System nochmal im Vor- oder Nachteil sein. Da hier eben eine andere Art des Grafikrenderings hinzu kommt. (WPF Anwendungen können bei der Grafikdarstellung von entsprechende Grafikhardware gebrauch machen, wenn vorhanden. Aber wenn eben ein schwaches System mit der angeforderten opulenten Darstellung überfordert ist wird WPF sicherlich nicht schneller sein als das grafisch anspruchslose .NET Forms)

Weiter würde ich gerne nachfragen:
Bist du sicher das es am .NET Framework liegt und nicht evtl. an anderen Komponenten wie zum Beispiel dem SQL Server den du aus deiner Anwendung heraus verwendest?
Aus Erfahrung zum Beispiel weiß ich das ein neu gestarteter SQL Server auch erst mal ein bisschen Zeit braucht um warm zu werden.

Die Exception Meldung läßt mich vermuten das du eine TargetInvocatioNException bekommst.
Bei diesem Exception Typ steht der eigentlich wichtige Inhalte tiefer verschachtelt in der InnerException Property der Exception.
Am besten mal diese Auswerten (rekursiv bis keine InnerExceptions mehr gesetzt sind)

Wenn das nicht weiter hilft um das Problem einzugrenzen dann empfehle ich das Assembly Binding Log zu aktivieren
Fuslogvw.exe (Assembly Binding Log Viewer)

Das hilft in der Regel beim identifizieren was beim laden einer Assembly wirklich schief läuft.

Wenn das Programm2 nicht von dir ist, dann werden dir meine Links leider nichts nützen.

Um das Programm2 dann irgendwie zur Anzeige zu bewegen sind die von dir genannten API Befehle schon die richtigen.

Vielleicht rufst du ja aber die Befehle mit den falschen Handles auf, um das zu beurteilen kann dir das Programm Spy++ manchmal ganz hilfreich sein:
Introducing Spy++

Eine Interaktion mit dem Programm ist dann aber eben wirklich nur in dem Umfang möglich in dem du mit den verfügbaren Window Handles interagieren kannst. Es klingt aber so also du ja schon mal eine funktionierende Lösung hattest...

Das die ShowWindow Aufrufe seit Windows 7 nicht mehr so funktionieren, könnte mit den Umbauten unter der "Oberfläche von Windows" zu tun haben.
Hier wurde aus Sicherheitsgründen enorm viel geändert.
Was zum Beispiel nicht geht ist aus einem nicht priviligierten Prozess auf einen priviligierten Prozess zu zugreifen (das beinaltet eben auch ShowWindow Aufrufe)
Wenn also "Programm2" "Als Administrator" ausgeführt wird und dein Programm1 nicht, dann wird das unter Windows 7 definitiv nicht mehr so funktionieren wie das vor Windows 7 / Vista mal funktioniert hat.

Das Thema ist aber für einen blutigen C# Anfänger nicht unbedingt trivial.

Frage vorab: Sind beide Programme von dir?
Wenn ja, dann bietet es sich an was von Microsoft mitgeliefertes zu benutzen:
Im Namespace Microsoft.VisualBasic.ApplicationServices die Klasse WindowsFormsApplicationBase
Einen Einstig in die Benutzung geben die folgenden Links:
Single-Instance Applications and C#

WindowsFormsApplicationBase.StartupNextInstance Event

(Nicht von dem VisualBasic irritieren lassen. Das ist nur ein Namespace Bezeichner. Die Klasse und alles darin kann auch ohne weiteres in C# genutzt werden, siehe 1. Link)

Letztendlich ist das von Microsoft auch nur ein "Wrapper" um die Verwendung von "Mutex" und Co.
wie zum Beispiel hier erläutert:
Single Instance Form Application in C#

Wenn nicht beide Programme von dir sind, dürfte die ganze Thematik um ein vielfaches Anspruchsvoller werden ...

Aber schau dir erstmal an was ich so verlinkt habe ... HTH

Und wenn es alles andere fehlschlägt, einfach mal das Assembly Binding Log anschalten:

Habe ich mal gestartet, aber irgendwie kann ich damit nicht umgehen. Folgendes gemacht: mit Adminrechten aus der VS-Shell gestartet, dann mein Projekt im Debug-Modus gestartet, versucht die MySQL-Verbindung aufzubauen. Obig schon genannte Fehlermeldung(en), aber kein einziger Eintrag in der Assembly Binding Log.

---

Vielleicht hilft dir das ja weiter:
http://www.hanselman.com/blog/BackToBasicsUsingFusionLogViewerToDebugObscureLoaderErrors.aspx

Und wenn es alles andere fehlschlägt, einfach mal das Assembly Binding Log anschalten:
https://msdn.microsoft.com/en-us/library/e74a18c4%28v=vs.110%29.aspx

Und wenn es doch SQL sein soll, fallen mir spontan SQLite und Firebird ein.

Nächstes Treffen:

Wann?
Dienstag den 28.07.2015 um 19 Uhr

Wo?
Irish Pub
(Lammgasse 30, 74072 Heilbronn)
http://www.irishpub-heilbronn.de/

Inhalte:
Vermutlich wird das Hauptthema Visual Studio 2015 sein aber auch sonst wird wieder "gefachsimpelt" und sich einfach locker unterhalten zu allen Themen .NET (und auch Powershell)

Mit in .NET geschriebenem OCX kenne ich mich nicht wirklich aus.
Deswegen weiß ich auch nicht ob der folgende Tip überhaupt anwendbar ist, aber generell ist das folgende immer ein weg .NET Assembly Ladeprobleme zu analysieren:
Und zwar hilft da der Assembly Binding Log Viewer oder auch Fusion Log Viewer genannt:
https://msdn.microsoft.com/en-us/library/e74a18c4%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396

Hmmm, 21 MB da sind dann aber auch noch Nutzdaten mit dabei und nicht nur Solution und Source Dateien, oder?
Ne Möglichkeit das Projekt auf ein Proof-of-Concept zu reduzieren?
Im Zweifelsfall halt das ganze Paket irgendwo bereitstellen. Dropbox etc.

Die MSDN ist dein Freund 😉
Die IndexOf Methode hat eine Überladung mit der du angeben kannst ab welcher Position du suchen willst. https://msdn.microsoft.com/en-us/library/d93tkzah%28v=vs.110%29.aspx
Es gibt auch noch die LastIndexOf Methode https://msdn.microsoft.com/en-us/library/system.string.lastindexof%28v=vs.110%29.aspx
Diese erlaubt dir die Suche von hinten im String.

Letztendlich hilft aber alles nichts wenn du keine Programmlogik hast nach der du weißt an welcher Stelle du splitten mußt. Wenn also der gesuchte Teil wandert und es keine feste Logik gibt nach der man das beurteilen kann, dann wird das Problem nicht mehr trivial lösbar sein.

Wie wäre es denn mit der IndexOf (https://msdn.microsoft.com/en-us/library/k8b1470s%28v=vs.110%29.aspx) und Substring (https://msdn.microsoft.com/en-us/library/aka44szs%28v=vs.110%29.aspx) Funktion.
Zuerst suchst du mit der IndexOf Funktion das erste Leerzeichen. Und mit der Substring Funktion kannst du den String dann gezielt in zwei Teile zerlegen.

Sollte mit dem folgenden Event machbar sein:
AppDomain.AssemblyResolve-Event

Das Event wird immer ausgelöst wenn die .NET Runtime eine Referenz nicht auflösen kann.
In diesem Event kannst du dann deine eigene Logik einbauen wie und welche Assembly geladen werden soll.

Nun, jede weitere Idee wäre vermutlich auch nicht mehr hilfreich da sie meinerseits nur theoretischer Natur wäre.
Vielleicht kannst du ja mal die gesamte Solution packen und hochladen damit man sich mal das gesamtheitlich anschauen kann.

OK, noch ein Versuch:
Nach diesem Post (http://erikej.blogspot.de/2014/11/using-sqlite-with-entity-framework-6.html) zu urteilen fehlen dir tatsächlich noch Einträge in deiner Config.
Du brauchst noch das folgende zusätzlich zu den bereits vorhandenen EF6 Einträgen:

<remove invariant="System.Data.SQLite" />

<add name="SQLite Data Provider"
                     invariant="System.Data.SQLite"
                     description=".NET Framework Data Provider for SQLite"
                     type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" />

Lies dir auf jeden Fall noch den genannten Post durch, der könnte dir auch insgesamt noch zusätzlichen Nutzen erweisen.

Hi,

schau doch mal ob das zufällig das gleiche Problem ist wie hier beschrieben:
http://stackoverflow.com/questions/20460357/problems-using-entity-framework-6-and-sqlite

Vermutlich häufigster Grund:
Die Assemblies / DLLs sind nicht im gleichen Verzeichnis wie das Programm bzw. die Assemblies sind auf dem System nicht im Global Assembly Cache.

Vermutlich häufigster Grund der zur Fehldiagnose führt:
Die Assemblies sind zwar im richtigen Verzeichnis haben aber die falsche Platform wie die Anwendung.
(z.B. Anwendung ist x86 und SQLite Assemblies sind x64 oder umgekehrt)

SQLite spezifisch:
SQLite benötigt eine Visual C++ Runtime (abhängig von der verwendeten SQLite Version - siehe Homepage von SQLite) die evtl. nicht installiert ist oder auch hier eben nicht in der richtigen Version / Platform (x64 / x86)

Wenn es keines dieser Gründe ist, dürfte uns eine exakte Fehlermeldung weiterhelfen.

Gut, wußte nicht das Express kein Compact Framework kann. Das dachte ich, wäre allein durch die Anfrage bereits geprüft worden ...
Denn für mich stellt sich nun die Frage wie mogel dann um eine Lizenz für eine Vollversion von Visual Studio 2008 herumkommen will?

Kurz gesagt ... ich bin raus 😉

PS: In einer aktiven MSDN Lizenz gibt es Visual Studio 2008 noch zum Download. Habe ich selber erst bei der Arbeit vor ein paar Wochen benötigt (mußte auch CF Framework programmieren)

Die Express Edition gibt es noch hier zu finden:
http://winfuture.de/downloadvorschalt,2088.html

Schau doch mal ob dir die Antwort von hier: Visual Studio 2013 Service Reference weiterhilft.

Kann mir nicht vorstellen das etwas derart essentielles wie eine Webservice Referenz in der Community Edition nicht verfügbar wäre.