Als Hash könnte für Dich auch noch MurMur3 in Frage kommen. Das sollte nochmal ein Stück schneller sein als MD5, ist aber keine kryptographische Hash-Funktion (was in Deinem Fall ja wurscht sein sollte).
Eine weitere NoSQL-DB, die ich in diesem Thread noch nicht entdeckt habe (edit: und die für Deinen Fall passen sollte) wäre LMDB.

Ouch! UPnP 😃

So weit ich weiß, ist irgendwo in den Tiefen ihres Repositories ein solcher Codegenerator enthalten: LINN Open Source Upnp Lib
Möchte jetzt aber nicht meine Hand dafür ins Feuer legen.. ist schon lange her..

@Coder007:
Werde in nächster Zeit auch mal testweise aufs 2015er wechseln.Dort sind die Xamarin-Tools ja schon gebündelt (bzw. man kann sie direkt aus dem VS-Setup mitinstallieren). Wenn MS sowas anbietet, dann gehe ich schon auch davon aus, dass sie das anständig getestet haben. Mal sehen...

C++ hab ich bislang in VS noch nicht gemacht..

Schau mal hier: Eigener Hotspot - Captive Portal
Sollte das Selbe Thema sein wenn ich das richtig verstanden habe.

Wenn du weist das etwas Probleme macht, musst du es nicht immer wieder machen.

Eben. Html5 😉

@Abt:
Bei Dir gehen also die Exception-Filter? Konnte die neuste Version leider noch nicht wirklich testen, da VS (2013) beim Auftreten der ersten Exception mit der neuen Version des Plugins abraucht. Musste dann auf die Vorversion zurückrollen um weiterarbeiten zu können (nicht das erste Mal). Nach dieser Erfahrung eröffnete ich den Thread.

Erstmal Danke fürs Feedback.

Natürlich war Android am Anfang schwer gewöhnungsbedürtig, nach nem halben Jahr hatte das sich allerdings weitestgehend erledigt. Habe einen Foreground-Service und eine GUI drauf. Von daher also nichts ungewöhnliches.

Die ersten Probleme vielen mir mit dem VisualStudio Plug-in für Android auf. Visual Studio ist für mich zum Debuggen der App teilweise nahezu unbenutzbar. Es macht dabei keinen Unterschied ob ich ein echtes Gerät (S5) oder den Xamarin Android Player (der im übrigen eigentlich ganz gut läuft) verwende.

Symptome sind z.B. einfrierendes VS mit der Meldung "Visual Studio ist ausgelastet" beim inspizieren von Variablen (mouse-over). Das kommt dann auch nie wieder und der Prozess muss abgeschossen werden. Häufigkeit ca. 10-20 mal am Tag.

Außerdem werden Brakepoints oft nicht getroffen (vor allem in asynchronen Lambdas), das hat sich allerdings zuletzt stark verbessert. Debugger.Break() funktionierte hingegen meistens, machmal allerdings auch nicht, dann brach das Debugging entweder ab und die App lief auf dem Gerät ganz normal weiter oder VS fror ein, schmierte ab (mal mit, mal ohne die App zu beenden), .ignorierte Debugger.Break() einfach, ...

Im VisualStudio funktionieren die Exception-Filter nicht. D.h. ich kann entweder nur an allen auftretenden Exceptions anhalten oder nur an unbehandelten. Einzelne wie. z.B. Exceptions in einer Library (die dort allerdings auch alle behandelt werden) können nicht ausgenommen werden und führen dazu, dass die Ausführung angehalten wird wenn ich eigentlich nur bei einer auftretenden Exception halten möchte.

Ich probierte dann Xamarin Studio aus. Es viel mir sofort auf das das Debugging dort wesentlich besser lief. Exception Filter funktionieren und die Performance ist deutlich besser als mit dem VS-Plugin. Manchmal schmiert es beim Inspizieren von Variablen allerdings auch einfach ab und Breakpoints in Lambdas verhalten sich extrem merkwürdig: Die Brakepoint-Markierung rutscht während der Ausführung an die nächste Stelle nach der Expression (bei verschachtelten bis nach ganz außen) und der Debugger hält dann irgendwo, aber nicht in dem Scope den ich debuggen möchte. Das wiederum funktioniert prinzipiell im VS.

Der Editor ist leider ein weiterer Knackpunkt von XS und steht in keinem Vergleich zu dem von VS.

Ich nutze für klassische .Net Projekte schon lange VS und hatte nie irgendwelche Probleme derart, die sich nicht mit einem "Rebuild All" hätten beseitigen lassen. Privat nutze ich schon seit längerem Debian mit MonoDevelop 5.4 (aus dem Repository) und hatte bis auf einige Abstürze und den Texteditor dort auch nichts weiter zu beklagen.

Wenn man ein bisschen durchs Forum (Xamarin) schaut, findet man auch andere Benutzer die Teilweise massive Probleme mit den Werkzeugen haben. Im Allgemeinen scheint allerdings ein recht positives Bild vorzuherrschen. Wenn mal etwas auf dem Gerät deployed ist, dann läuft das auch anständig. An der Runtime an sich gibt es also gar nichts auszusetzen. Auch die Integration von Jars funktionierte bisher immer gut. Aber in den Tools scheinen mir ein paar Heisenbugs zu stecken.

Servus zusammen,

ich wollte in diesem Thread einfach mal in die Runde fragen ob hier jemand mit Xamarin arbeitet und welche Erfahrungen damit gemacht wurden.

Zu meinen Erfahrungen:
Ich bin inzwischen extrem frustriert. Zwischenzeitlich kamen auch schon mal selbstzweifel auf, ob ich eventuell einfach nur zu blöd bin um das ganze richtig zu verwenden wenn man so die Lobeshymnen andere Entwickler liest, die scheinbar auf Xamarin schwören.
Inzwischen kann ich mir gut vorstellen, dass alle die solche "Lobeshymnen" schreiben entweder gekauft sind oder vielleicht nur die nächste Furz-App bauen.
Zumindest bei mir funktioniert von den Entwicklungswerkzeugen nämlich so gut wie nichts wie es soll. Und das selbst mit der vor zwei Tagen releasten Version 4, dem "stabilstem Xamarin aller Zeiten".

Meine nächste Multi-Plattform app mach ich mit HTML5 und JS - schwöre!

Wie ergeht es euch mit dem Ding?

Hallo mar.k,

habe noch ein bisschen gewühlt und folgendes "Cheat-Sheet" gefunden welches Dich weiterbringen sollte: How to write managed code that uses the mobile broadband API.

Hier die API-Übersicht: Mobile Broadband API Interfaces

Im Speziellen für die Signalstärke: IMbnSignal interface

Dazu gibts hier auch noch direkt ein Snippet: Snippet: Get signal strength

Ich denke das sollte Dich erstmal weiter bringen. Scheint wohl auch alles ohne WMI zu gehen (bzw. gar nicht mit der WMI..) Wollte Dich nicht auf die falsche Fährte bringen, bislang konnte ich immer alle Net-Infos aus der WMI bekommen, die Zeiten scheinen sich zu ändern...

Gruß,
jaensen

Gerade drübergestolpert: Eigener visueller Designer [inkl. Trigger Code]

Wenn Du den IIS auf Deinem Rechner installiert hast, dann kannst Du aus dem VS heraus mit Hilfe des Punktes "Veröffentlichen" oder "Deploy" die Anwendung einfach in eine IIS-Site ausrollen. Wenn Du dann von lokal darauf zugreifen kannst, dann musst Du dich halt noch um die richtigen Firewall-Einstellungen kümmern.

Anleitungen, wie man den Zugriff auf den IISExpress (mit dem in aktuellen VS standardmäßig die Webanwednungen zum debugging gestartet werden) von "außen" zulässt gibt es im Internet auch genügend.

Das sollte aber auch alles mit Hilfe einer Suchmaschine lösbar sein. Der von Dir verlinkte Beitrag WebService läuft nur mit localhost nicht mit IP ist übrigens fast sechs Jahre alt... Eine lange Zeit in der Software-Welt.

Es soll auch ausschließlich um Lan verfügbar sein.

Das ist eben Aspekt den Du mit dem Programm nicht beinflussen kannst und um den sich der Netzwerkadministrator kümmern muss. WebApi-Projekte heißen nur so, weil sie vornehmlich im Web-Umfeld verwendet werden und weil sie Web-Technologien verwenden.

Wie wäre es, wenn Du einfach aus dem Visual Studio WebApi-Template ein neues Testprojekt anlegst und erstmal mit einer Hallo-Welt-Methode experimentierst?! Ich bin mir sicher dass Du mit dem Testprojekt und einem Browser schnell rausfinden wirst ob das für Deine Anforderungen passt.

Er möchte seine Web Api im eigenen Lan zur Verfügung stellen

Das hat erstmal gar nichts mit der WebAPI zu tun sondern eher damit, wie das Netzwerk bzw. die Firewall(s) konfiguriert sind. Normalerweise ist das LAN grundsätzlich nicht von "außen" erreichbar. Alles andere wäre auch grob fahrlässig.

Hmm.. kenne den HttpRequest aus System.Web gerade nicht genau aber ich glaube, dass wenn Du auf die "Form"-Eigenschaft zugreifst, die den Stream bereits ließt.

Servus KevinHappy,

Dein Fall schaut aus als on Du in Deiner SQL-Abfrage eigentlich nur einen JOIN benötigen würdest:

SELECT * FROM article_list_export
   JOIN article_list_export_ean ON article_list_export_ean.article_ordernr = article_list_export.ordernr

Damit kannst Du die verschachtelte Abfrage innerhalb der while-Schleife weglassen und musst auch nicht so viele Anfragen an den Server stellen.
Das dürfte unterm Strich ein Vielfaches schneller sein als Dein jetziger Code.

Noch ein weiterer Tipp: Benutze für Datenbankresourcen (Connection, Command etc.) immer die using-Anweisung anstatt manuell Close und Dispose aufzurufen. Die Using-Anweisung ruft auch im Falle einer Exception immer Dispose auf so dass Du die Try-Catch-Blöcke in deinem Code weglassen kannst.

Generell gilt, dass man Exceptions nur dann fängt, wenn man sie an der Stelle auch sinnvoll behandeln kann. In Deinem Fall würden einfach Daten weggelassen werden falls es zu einem Fehler kommt was ziemlich unvorhersehbares Verhalten hervorrufen kann.

Logging kannst Du auch weiter "oben" in Deinem Code einbauen. Wenn z.B. die MySqlException nicht gefangen wird, landet sie früher oder später in der Main-Methode Deines Programms. Dort kannst Du sie immer noch Loggen.

Kannst Dir ja mal die Beispiele unter: http://www.optaplanner.org/ reinziehen. Das ist eine Open Source Optimierungssoftware. Trifft sehr genau das was Du machen möchtest, ist aber leider in Java. Könntest Du also entweder als Kommandozeilentool oder mit IKVM verwenden.

Servus!

Sollte über WMI machbar sein: WMI Get network interface configuration

Nur mal so in den Raum geworfen ohne Deine genauen Anforderungen zu kennen: Könnten Dir Java Object Spaces was bringen? (Introduction to Jini)

Unterstützt:

• In-memory cache
• Verteilung
• Persistenz
• Notifications

Ist nicht genau das was Du suchst, aber ich denke es bewegt sich definitiv in die richtige Richtung.

Könnte man wahrscheinlich mit IKVM auch unter .Net zum laufen bringen oder Du könntest dich davon für Deine Eigenentwicklung inspirieren lassen.

Auch von mir herzlichsten Dank für das riesen Engagement und viel Erfolg mit den weiteren Vorhaben!

Kann getrost sagen, dass mir dieses Forum vom Einstieg in C# bis jetzt ein treuer und guter Begleiter war und ich hoffe auch das das so bleibt, auch wenn ich selbst momentan kaum noch Zeit investieren kann.

Ist auch eine Frage was denn mit den Daten im Client hauptsächlich passieren soll und wie viele es sind.

Habe vor kurzem ganz gute Erfahrungen damit gemacht Sqlite in einer Client-Anwendung, die ihre Daten
aus verschiedenen Quellen bezieht zu verwenden.

Die Anwendung besteht im Wesentlichen aus Listen mit Geschäftsvorgängen, die einem oder mehreren Mitarbeitern bzw. Kunden zugeordnet sind. Die Namen der Mitarbeiter und Kunden sollen in den Listen auch angezeigt werden.

Wenn auf die Stammdaten ohnehin nur lesend zugregriffen wird, dann kannst du die DB als schnellen in-memory cache betrachten. Downside: ich habe keinen Weg gefunden die Datenbanken zu transferieren, ohne sie vorher in ein File zu speichern. Das geht mit der Backup-Api: PInvoke-Signaturen für die SQLite Backup-API

Wenn man nicht wie ich in diesem Fall an SQLite gebunden ist, denke ich wird man evtl. passendere DBs finden. Der Ansatz funktioniert aber ziemlich gut.

Du wirst auch einen CRM Nutzer brauchen, wenn du nicht direkt mit der Datenbank, sondern mit dem Webservice kommunizierst.

Ist prinzipiell auch besser so, da so eben die Datenintegrität und Audit-Fähigkeit erhalten bleibt. Meist greift man eher nur lesend direkt auf so eine Applikationsdatenbank für BI etc. zu. Außerdem müsste man wohl auch noch schauen wie es Lizenzrechtlich aussieht.

Beschreibung:
Ich stand gerade vor dem Problem eine in-memory SQLite Datenbank persistieren zu müssen und bin dabei über die SQLite Backup API gestolpert die genau das ermöglicht.

Im offiziellen ADO.Net Provider scheint diese Funktionalität bereits implementiert zu sein. Da ich allerdings mit Xamarin für Android arbeite, muss ich Mono.Data.Sqlite verwenden wo diese Funktionalität noch nicht enthalten ist.
Deshalb hierfür ein Snippet welches ich euch nicht vorenthalten möchte:

using Mono.Data.Sqlite;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

    //
    // Alles aus Mono.Data.Sqlite übernommen + unten die Ergänzung um die Backup-API
    //
    [SuppressUnmanagedCodeSecurity]
    public static class UnsafeNativeMethods
    {
        public enum TypeAffinity
        {
            Uninitialized,
            Int64,
            Double,
            Text,
            Blob,
            Null,
            DateTime = 10,
            None
        }

        public enum SQLiteConfig
        {
            SingleThread = 1,
            MultiThread,
            Serialized
        }

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate void SQLiteCallback(IntPtr context, int nArgs, IntPtr argsptr);

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate void SQLiteFinalCallback(IntPtr context);

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate void SQLiteUpdateCallback(IntPtr puser, int type, IntPtr database, IntPtr table, long rowid);

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate int SQLiteCommitCallback(IntPtr puser);

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate void SQLiteRollbackCallback(IntPtr puser);

        [UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.Cdecl)]
        internal delegate int SQLiteCollation(IntPtr puser, int len1, IntPtr pv1, int len2, IntPtr pv2);

        private const string SQLITE_DLL = "sqlite3";
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_close(IntPtr db);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_create_function(IntPtr db, byte[] strName, int nArgs, int nType, IntPtr pvUser, SQLiteCallback func, SQLiteCallback fstep, SQLiteFinalCallback ffinal);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_create_function_v2(IntPtr db, byte[] strName, int nArgs, int nType, IntPtr pvUser, SQLiteCallback func, SQLiteCallback fstep, SQLiteFinalCallback ffinal, SQLiteFinalCallback fdestroy);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_finalize(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_open_v2(byte[] utf8Filename, out IntPtr db, int flags, IntPtr vfs);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_open(byte[] utf8Filename, out IntPtr db);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        internal static extern int sqlite3_open16(string fileName, out IntPtr db);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_reset(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_bind_parameter_name(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_database_name(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_database_name16(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_decltype(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_decltype16(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_name(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_name16(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_origin_name(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_origin_name16(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_table_name(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_table_name16(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_text(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_text16(IntPtr stmt, int index);

        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_errmsg(IntPtr db);

        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_prepare(IntPtr db, IntPtr pSql, int nBytes, out IntPtr stmt, out IntPtr ptrRemain);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_table_column_metadata(IntPtr db, byte[] dbName, byte[] tblName, byte[] colName, out IntPtr ptrDataType, out IntPtr ptrCollSeq, out int notNull, out int primaryKey, out int autoInc);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_value_text(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_value_text16(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_libversion();
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_interrupt(IntPtr db);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_changes(IntPtr db);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_busy_timeout(IntPtr db, int ms);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_blob(IntPtr stmt, int index, byte[] value, int nSize, IntPtr nTransient);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_double(IntPtr stmt, int index, double value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_int(IntPtr stmt, int index, int value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_int64(IntPtr stmt, int index, long value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_null(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_text(IntPtr stmt, int index, byte[] value, int nlen, IntPtr pvReserved);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_parameter_count(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_bind_parameter_index(IntPtr stmt, byte[] strName);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_column_count(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_step(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern double sqlite3_column_double(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_column_int(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern long sqlite3_column_int64(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_column_blob(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_column_bytes(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern TypeAffinity sqlite3_column_type(IntPtr stmt, int index);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_create_collation(IntPtr db, byte[] strName, int nType, IntPtr pvUser, SQLiteCollation func);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_aggregate_count(IntPtr context);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_value_blob(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_value_bytes(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern double sqlite3_value_double(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_value_int(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern long sqlite3_value_int64(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern TypeAffinity sqlite3_value_type(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_blob(IntPtr context, byte[] value, int nSize, IntPtr pvReserved);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_double(IntPtr context, double value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_error(IntPtr context, byte[] strErr, int nLen);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_int(IntPtr context, int value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_int64(IntPtr context, long value);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_null(IntPtr context);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern void sqlite3_result_text(IntPtr context, byte[] value, int nLen, IntPtr pvReserved);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_aggregate_context(IntPtr context, int nBytes);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        internal static extern int sqlite3_bind_text16(IntPtr stmt, int index, string value, int nlen, IntPtr pvReserved);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        internal static extern void sqlite3_result_error16(IntPtr context, string strName, int nLen);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
        internal static extern void sqlite3_result_text16(IntPtr context, string strName, int nLen, IntPtr pvReserved);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_key(IntPtr db, byte[] key, int keylen);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_rekey(IntPtr db, byte[] key, int keylen);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_update_hook(IntPtr db, SQLiteUpdateCallback func, IntPtr pvUser);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_commit_hook(IntPtr db, SQLiteCommitCallback func, IntPtr pvUser);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_rollback_hook(IntPtr db, SQLiteRollbackCallback func, IntPtr pvUser);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_db_handle(IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_next_stmt(IntPtr db, IntPtr stmt);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_exec(IntPtr db, byte[] strSql, IntPtr pvCallback, IntPtr pvParam, out IntPtr errMsg);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_config(SQLiteConfig config);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_user_data(IntPtr context);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_free(IntPtr ptr);
        
        //
        // Hier sind die neuen Signaturen:
        //
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr sqlite3_backup_init(
          IntPtr pDest,                        /* Destination database handle */
          string zDestName,                 /* Destination database name */
          IntPtr pSource,                      /* Source database handle */
          string zSourceName                /* Source database name */
        );
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_backup_step(IntPtr p, int nPage);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_backup_finish(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_backup_remaining(IntPtr p);
        [DllImport("sqlite3", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int sqlite3_backup_pagecount(IntPtr p);
    }


    public static class SqlliteBackup
    {
        public static IntPtr GetDbHandleFromConnection(SqliteConnection connection)
        {
            Type sqliteConnectionType = typeof(SqliteConnection);
            var _sqlField = sqliteConnectionType.GetField("_sql", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

            var _sqlFieldValue = _sqlField.GetValue(connection);
            var _sqlFiedlType = _sqlFieldValue.GetType();

            var inner_sqlField = _sqlFiedlType.GetField("_sql", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
            var inner_sqlFieldValue = inner_sqlField.GetValue(_sqlFieldValue);

            var handleField = inner_sqlFieldValue.GetType().GetField("handle", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
            return (IntPtr)handleField.GetValue(inner_sqlFieldValue);
        }

        public static string Backup(IntPtr dbHandle)
        {
            if (dbHandle == IntPtr.Zero)
                throw new ArgumentException("The database which should be backed up is not specified (dbHandle == IntPtr.Zero).", "dbHandle");

            string emptyDb = "empty.db";  // Für Android hier Pfad z.B. auf sdcard anpassen
            IntPtr dstDb = IntPtr.Zero;

            string dstDbFileName = Guid.NewGuid().ToString() + ".db"; // Für Android hier Pfad z.B. auf sdcard anpassen
            File.Copy(emptyDb, dstDbFileName);

            if (UnsafeNativeMethods.sqlite3_open(Encoding.UTF8.GetBytes(dstDbFileName), out dstDb) != 0)
                ThrowErrMsg(dstDb);

            var pBackup = UnsafeNativeMethods.sqlite3_backup_init(dstDb, "main", dbHandle, "main");
            if (pBackup == IntPtr.Zero)
                ThrowErrMsg(dstDb);

            // Copy all DB-Pages at once (-1)
            if (UnsafeNativeMethods.sqlite3_backup_step(pBackup, -1) != 101)
                throw new Exception("SQLite should backup all pages at once but didn't finish.");

            if (UnsafeNativeMethods.sqlite3_backup_finish(pBackup) != 0)
                ThrowErrMsg(dstDb);

            UnsafeNativeMethods.sqlite3_close(dstDb);

            return dstDbFileName;
        }

        public static void ThrowErrMsg(IntPtr dbHandle)
        {
            var msgPtr = UnsafeNativeMethods.sqlite3_errmsg(dbHandle);
            throw new Exception(string.Format("Error while openig the destination database: {0}", Marshal.PtrToStringAnsi(msgPtr)));
        }
    }

So verwendet man das ganze:

            _connection = new SqliteConnection("URI=file::memory:,version=3");
            _connection.Open();

            // Do something with the in-memory db

            string pathToPersistedDb = SqlliteBackup.Backup(SqlliteBackup.GetDbHandleFromConnection(_connection));

            _connection.Close();

Ich habe es mir hier ein bisschen einfach gemacht und verwende eine leere Datenbank, die vor jedem Backup einmal kopiert wird und dann das Ziel darstellt.
Damit das ganze also funktioniert, muss eine leere Datenbank mit dem Namen "empty.db" vorhanden sein (Funktioniert so nicht 1:1 auf Android, dort muss die leere Datenbank in den Assets mitgeliefert oder zur Laufzeit erzeugt werden und dann alles weitere an einer Stelle mit Schreibzugriff stattfinden (z.B. sdcard)).
Es werden auch alle Pages auf einmal kopiert was bei größeren DBs problematisch werden könnte.

Damit man die SqliteConnection weiterverwnden kann und nicht alles über diese PInvoke-Signaturen machen muss, habe ich noch einen kleinen dreckigen Helper gebaut (GetDbHandleFromConnection) der das DB-Handle per Reflection aus einer SqliteConnection-Instanz holt. Hier muss man bei Updates höllisch aufpassen! (am besten einen Build-Task bauen der fehlschlägt, wenn die Version des Mono.Data.Sqlite-Assemblies eine andere Version hat als (bei mir) 2.0.5.0).

Schlagwörter: Mono.Data.Sqlite; Backup; PInvoke

Servus,

wenn es nicht essenziell ist, dass die Prozesse sofort angezeigt werden wenn sie gestartet werden (was wie es aussieht der Fall ist) dann wäre es wohl die einfachste Möglichkeit einfach mit Process.GetProcesses() die laufenden Prozesse in einem Intervall abzufragen.

Ansonsten scheint es auch mit der WMI zu funktionieren wie in diesem Stackoverflow-Beitrag beschrieben: How to detect win32 process creation/termination in c++ welcher wiederum auf die MSDN verlinkt: Example: Receiving Event Notifications Through WMI

Einen Service wirst Du nur brauchen wenn die Anwendung auch ohne angemeldeten Benutzer laufen soll. Man könnte dazu meines Wissens nach auch den Windows Task Scheduler mißbrauchen..

Auf einen Service könntest Du von Deiner Tray-Icon Anwendung aus per IPC-Mechanismen zugreifen. Das könnte auch ein WCF-Service sein (alternativ: Named Pipes, Memory Mapped Files ...)

Ein Bild sagt mehr als tausend Worte.
Und nein, es ist leider nicht die einzige Klasse die so aussieht. Zum Glück hat die Klasse nur 230 Methoden sonst würde man sich ja gar nicht mehr zurecht finden 😃

Ohne den Webservice jetzt zu kennen würde ich sagen das alle Mails die als "To"-Adresse xxx@deine-domain.com haben eingehende E-Mails sind und der Rest ausgehende..

Servus,

du kannst die MainForm z.B. im Konstruktor als Parameter übergeben oder ein Property an deiner zweiten Form anbringen. Alles in allem aber eher ein Fall für:
[FAQ] Kommunikation von 2 Forms

Beschreibung:
Ich musste neulich ein paar Datensätze unter Beachtung der ihrer Hierarchie sortieren und brauchte dafür einen kleinen Helfer den ich hier gerne zur Verfügung stelle:

        public struct Hierarchy : IComparable
        {
            private int[] _parts;

            public Hierarchy(string path, string seperator = "/")
            {
                if (path == null)
                    throw new ArgumentNullException("path");
                if (seperator == null)
                    throw new ArgumentNullException("seperator");

                string[] pathParts = path.Split(new string[] { seperator }, StringSplitOptions.RemoveEmptyEntries);
                _parts = new int[pathParts.Length];

                for (int i = 0; i < pathParts.Length; i++)
                {
                    int parsed = 0;
                    if (!int.TryParse(pathParts[i], out parsed))
                        throw new Exception("The input path has the wrong format. Allowed format is: /int/int/int or int/int/int");

                    _parts[i] = parsed;
                }
            }

            public static bool operator >(Hierarchy h1, Hierarchy h2)
            {
                int l = h1._parts.Length >= h2._parts.Length ? h1._parts.Length : h2._parts.Length;

                for (int i = 0; i < l; i++)
                {
                    if (i > h1._parts.Length - 1 || i > h2._parts.Length - 1)
                        break;

                    int v1 = h1._parts[i];
                    int v2 = h2._parts[i];

                    if (v1 == v2)
                        continue;

                    return v1 > v2;
                }

                return false;
            }

            public static bool operator <(Hierarchy h1, Hierarchy h2)
            {
                int l = h1._parts.Length >= h2._parts.Length ? h1._parts.Length : h2._parts.Length;

                for (int i = 0; i < l; i++)
                {
                    if (i > h1._parts.Length - 1 || i > h2._parts.Length - 1)
                        break;

                    int v1 = h1._parts[i];
                    int v2 = h2._parts[i];

                    if (v1 == v2)
                        continue;

                    return v1 < v2;
                }

                return false;
            }

            public static bool operator ==(Hierarchy h1, Hierarchy h2)
            {
                if (h1._parts.Length != h2._parts.Length)
                    return false;

                for (int i = 0; i < h1._parts.Length; i++)
                {
                    if (h1._parts[i] != h2._parts[i])
                        return false;
                }

                return true;
            }

            public static bool operator !=(Hierarchy h1, Hierarchy h2)
            {
                if (h1._parts.Length != h2._parts.Length)
                    return true;

                for (int i = 0; i < h1._parts.Length; i++)
                {
                    if (h1._parts[i] == h2._parts[i])
                        return false;
                }

                return true;
            }

            public int CompareTo(object obj)
            {
                if (!(obj is Hierarchy))
                    return 1;

                Hierarchy h = (Hierarchy)obj;
                if (h > this)
                    return 1;
                else if (h < this)
                    return -1;
                else
                    return 0;
            }

            public override bool Equals(object obj)
            {
                if (!(obj is Hierarchy))
                    return false;

                Hierarchy h = (Hierarchy)obj;
                return h == this;
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    int hash = 0;
                    for (int i = 0; i < _parts.Length; i++)
                    {
                        hash = i ^ _parts[i] + hash;
                    }
                    return hash;
                }
            }
        }

Verwendung läuft folgendermaßen:

            Hierarchy h1 = new Hierarchy("/123/123/123/123/123/123");
            Hierarchy h2 = new Hierarchy("123/123/123/123/123/123");
            Hierarchy h3 = new Hierarchy("123/123/123/123/123/123/");

            // h1 == h2 = true
            // h2 == h3 = true

           Hierarchy h4 = new Hierarchy(".123.123.123.123.123.123", ".");
           // h3 == h4 = true

Schlagwörter: Hierarchie, Baum, Tree, sortieren, Sortierung

Servus,

damit Du typisierte Parameter übergeben kanns musst du einen eigenen Delegaten erstellen (oder einen der bereits enthaltenen Func und Action verwenden):

	public delegate void CmdDelegate (string param);

Der enthät die Methodensignatur hier void als return value und einen string Parameter.

	class Test
	{

		List<KeyValuePair<string,CmdDelegate>> cmds = new List<KeyValuePair<string,CmdDelegate>>();

		public Test ()
		{
			cmds.Add(new KeyValuePair<string, CmdDelegate>("test1",Cmd1Handler));
			cmds.Add(new KeyValuePair<string, CmdDelegate>("test2",Cmd2Handler));
		}

		public void Handle (string cmd, string param)
		{
			foreach (var item in cmds) {
				if (item.Key != cmd)
					continue;


				CmdDelegate cmdDelegate = item.Value;

				cmdDelegate(param);
			}
		}

		private string _irgendwas = "_irgendwas";


		private void Cmd1Handler (string param)
		{
			Console.WriteLine("test1" + param + _irgendwas);
		}
		private void Cmd2Handler (string param)
		{
			Console.WriteLine("test2" + param +_irgendwas);
		}
	}

	public delegate void CmdDelegate (string param); // <-- Delegate

	class Program
	{

		static void Main (string[] args)
		{
			Test test = new Test();
			test.Handle("test1", "blubb");
			test.Handle("test2", "BLUBB");
		}
	}

Ist zwar noch in einem frühen Stadium aber sicherlich für die nähere Zukunft beachtenswert: BittorrentSync.
Support für Mobilgeräte soll noch kommen aber BT Clients für Android gibt es ja bereits:Google Play Store:BitTorrent App

Servus,

klingt so als ob Du dafür den Dijkstra-Algorithmus nicht benötigen würdest da du ja keine Pfade zwischen Knoten finden möchtest. Das sollte mit einer einfachen Tiefensuche machbar sein in dem Du einfach bei jedem Schritt die nächste Kantenlänge addierst und prüfst ob sie noch innerhalb der max. zulässigen entfernung ist oder nicht.

Also wenn es wirklich nur am Fokus liegen sollte kannst du mal probieren ob ein senden von WM_SETFOCUS ausreichend ist (Über FindWindowEx kommst du an das benötigte Handle).

Ansonsten stellts sich natürlich die Frage was du damit anstellen möchtest und ob es nicht eventuell einfachere Wege gibt.

Würde ich mit Regex machen:
.NET Framework Regular Expressions

Dieser Thread sollte alles nötige bereithalten: WebClient mit HTTP-POST- und Cookie-Unterstützung

Wenn deine WHERE-Klausel auch klassischerweise ein String sein darf: Dynamic Linq

Mein Code war für den SQL-Server. Musst halt die ODBC-Klassen statt den Sql-Klassen verwenden dann sollte es auch klappen.

Das kannst du dir aber alles leicht in einem ADO.Net Tutorial aneignen.

Du benötigst den EDITDesigner nicht um das DataGridView zu verwenden. Folgendes sollte ausreichen:

    public partial class Form1 : Form {
        public Form1() {
            InitializeComponent();

            Timer t = new Timer();
            t.Interval = 1000;
            t.Tick += (s, e) => {
                dataGridView1.DataSource = ExecQuery("Blubb");
            };

            t.Start();
        }


        private DataTable ExecQuery(string condition) {
            DataTable result = new DataTable();

            using (SqlConnection connection = new SqlConnection("MyConnectionString")) {
                connection.Open();

                using (SqlCommand cmd = new SqlCommand("SELECT * FROM MyTable WHERE [Condition] = @Condition", connection)) {
                    cmd.Parameters.Add("Condition", condition);

                    using (SqlDataAdapter adapter = new SqlDataAdapter(cmd)) {
                        adapter.Fill(result);
                    }
                }
            }

            return result;
        }
    }

Stimmt natürlich... Shame on me 😃

Tipp:
Benutze eine DataGridView mit conditional formatting und DataBinding. Dann kannst du im Hintergrund einfach die DAtenquelle (wohl eine DataTable) aktualisieren und wenn dieser Vorgang abgeschlossen ist dann bindest du einfach die aktualisierte Datenquelle an das Grid. Das geht angenehm schnell und erfordert wenig GUI und Layout-Code.

Hallo Gnozo,

wie meine Vorposter schon schrieben ist es meist nicht so einfach ein komplettes Programm auf Multithreading umzustellen. Da sich Deine Frage aber scheinbar nur darauf bezieht eine Methode in mehreren Threads auszuführen sollte das recht einfach mit einem Producer/Consumer Muster möglich sein.

Grob skizziert:

• Einen Producer der die Dateinamen aus dem Filesystem ließt und in eine BlockingQueue schreibt.
• Je nach dem z.B. wie viele Kerne du hast startest du jeweils einen Consumer der nach und nach jeweils einen Dateinamen aus der Queue holt und abarbeitet.
• Wenn nichts in der Queue ist dann warten die Consumer so lange bis wieder Items zum abarbeiten da sind.

Als Einstieg kannst du herbivores Queue (SyncQueue <T> - Eine praktische Job-Queue) benutzen oder seit .Net 4.5 auch die BlockingCollection<T>.

Das funktioniert allerdings nur zuverlässig wenn deine Methode keine Seiteneffekte hat (Wirkungsfreiheit).

Servus Johnny B,

leider habe ich selber auch noch keine Praxiserfahrung damit sammeln können aber die Windows.Media Libraries sollten eigentlich einen relativ problemlosen Zugriff auf die Kamera(s) des Geräts sowie das Abspielen eines Streams ermöglichen.

Eine kleine Übersicht habe ich bei channel9 gefunden: Channel9 Powerpoint Präsentation über die Windows.Media APIs

Ich denke das du weniger ein Problem beim Implementieren der Clients bekommst als bei der Server-Software die du dann wahrscheinlich auch noch benötigst (Encoder, Queue etc..). Eventuell solltest du dich lieber nach einer fertigen kommerziellen oder OS-Lösung umsehen die auf Standards wie XMPP und WebM oder H264 basieren und dafür dann einen Client zu schreiben.

Hmmm... deine Ausführungen sind jetzt nicht besonders detailiert. Ich nehme an du kennst bereits das WebBrowser-Control aus WinForms?!

So weit ich das weiss kann man Flash-Objekte aus Javascript heraus steuern. Dann sollte folgendes helfen: Calling javascript code from WinForms WebBrowser control

Servus Crone,

ich habe mal testweise in einer Konsolenanwendung (.Net 4.5) versucht dein Problem nachzuvollziehen und dort funktioniert das De-/Serialisieren mit dem BinaryFormatter wunderbar.

Zum anderen stellt sich dann folgende Frage, Warum lassen sich IPEndPoints aber ohne Probleme im LAN Serialisieren.

Was meinst du damit? Es sollte wurscht sein über welches Medium du ein byte[] transportierst solange sichergestellt ist das die Daten auch wieder richtig zusammengesetzt werden und zuverlässig übertragen werden (verwendest du UDP???)

Hallo free.runn3r,

ich denke der Thread würde besser in "Rund um die Programmierung" passen und du solltest evtl. für die einzelnen Fragen seperate Threads aufmachen da der Schittpunkt ja recht allgemein "Sicherheit" ist es aber im Kern um verschiedene Konzepte geht.

Zu den Fragen:

Zu 1. gibt es bereits einen FAQ-Eintrag: [FAQ] DB-Password/Kennwort/Connection-String sicher speichern

Zu 2 u. 3 würde ich einen weiteren Vorschlag in die Runde werfen: Entwickel einen Service (WCF oder ASP.Net MVC) der Zugriff auf beide Datenbanken erhält. Dieser Service kann sich dann um das hin- und herschieben der Daten kümmern sowie auf Berechtigungen prüfen.
So kann dann beispielsweise die Fachabteilung etc. für die die Anwendung bestimmt ist auch ohne DB-Administratoren die Benutzer verwalten. Der Service wird auf einem sicheren System installiert und der Benutzer erhält die Daten nur nach erfolgreicher Anmeldung und wenn er sich in der richtigen Rolle befindet.

[EDIT]
Nachtrag: Von der Idee MD5 zum hashen der Passwörter zu benutzen kann ich nur abraten. Dieses verfahren gilt schon seit langem als unsicher und es gab in letzter Zeit genügend Datenlecks die das belegen (z.B. Linked In). Meiner Meinung nach sollte hier mindestens SHA256 verwendet werden.

Bin gerade über die Bitreactive Building Blocks gestolpert und dachte mir ich poste das hier einfach mal. Ist zwar Java aber schaut ziemlich vielversprechend aus.

Es kommt darauf an wie viel Flexibilität ihr benötigt aber grundsätzlich könnte man eine einheitliche Beschreibung für das Frontend (ähnlich XUL oder XAML) verwenden und die UI dann daraus generieren.
Databinding und Commands wären dann hier die Zauberwörter.

Ok, vor lauter Bäumen den Wald nicht mehr gesehen.
Folgender Code tut es:

    public class CustomSessionId : System.Web.SessionState.SessionIDManager {
        public override string CreateSessionID(HttpContext context) {
            return Guid.NewGuid().ToString();
        }
        public override bool Validate(string id) {
            try {
                Guid idtest = new Guid(id);
                if (idtest.ToString() == id)
                    return true;
            } catch {
                return false;
            }
            return false;
        }
    }

Fundstelle war: Custom SessionID In ASP.net 2.0

Servus zusammen,

ich bin gerade dabei einen eigenen SessionStateStoreProvider zu schreiben um ASP.Net die Sessions aus einem bestehenden System unterzujubeln (die ASP.Net Seite und ein weiterer Dienst sollen auf die gleichen Session-Daten in einer SQL-Db zugreifen).

Ablauf ist in etwa folgender:

1. Benutzer geht auf die Seite, meldet sich an und bekommt eine neue Session.
2. Benutzer führt eine Aktion aus die in dem Dienst gequeued wird. Die Session-Id wird dem WorkItem in der Warteschlange mitgegeben.
3. Wenn das WorkItem abgearbeitet wird ändert es in der Session des Benutzers daten.
4. ASP.Net seite arbeitet mit den aktualisierten Daten in der Session weiter.

Ist eigentlich eine Interprozesskommunikation über die Datenbank.

Problem ist nun das der Dienst sich bereits mit anderen Diensten den Session-Store teilt und dort als session id GUIDs vergeben werden. ASP.Net weigert sich allerdings eine GUID als gültige Session-Id zu akzeptieren. Ich benutze folgenden Code um die Session-ID zu ändern (exemplarisch):

            bool redirectAfterSesssionIdChange = false;
            bool cookieAfterSessionIdChange = false;

            SessionIDManager sessionIdManager = new SessionIDManager();
            string newId = Guid.NewGuid().ToString();
            sessionIdManager.SaveSessionID(context, newId, out redirectAfterSesssionIdChange, out cookieAfterSessionIdChange);

Ich bekomme hier immer folgende Exception:

Cannot save the session id because it is invalid. Session ID=773cca4c-2d64-4e4b-84af-6105fe6ec76a

Es funktioniert natürlich wenn ich ASP.Net die SessionId selbst vergeben lasse:

            SessionIDManager sessionIdManager = new SessionIDManager();
            string newId = sessionIdManager.CreateSessionID(context);
            sessionIdManager.SaveSessionID(context, newId, out redirectAfterSesssionIdChange, out cookieAfterSessionIdChange);

Eine Lösung die mir hier spontan einfallen würde ist einfach einen weiteren Wert im Cookie abzulegen in dem die Session-Id aus der DB "gemappt" ist. Mir wäre es allerdings lieber wenn ich ASP.Net meine SessionId unterschieben könnte.

Irgendwelche Ideen?

Hast du die ffmpeg binaries für deine Architektur in deinem Anwendungsverzeichnis liegen?

INotifyPropertyChanged könnte für dich ebenfalls interessant sein.

Die Anzahl der Kerne kann man mittels Environment.ProcessorCount ermitteln. Aber ich stimme chilic zu das man in den meisten Fällen wohl besser fährt wenn man die Verteilung der Threads über die Kerne dem Scheduar überlässt da man keinen Kern exklusiv reservieren kann.

Außerdem verwende lieber den Threadpool als eigene Threads zu erstellen.