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.
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...
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.
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.
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!
Inzwischen hat sich in dem Bereich ja doch ein bisschen was getan.
Was man sich wohl ansehen sollte wenn man über diesen Thread stolpert, wäre wohl Sirius.
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...
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.
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.
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.
Zitat von MrSparkle
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).
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.
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..
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
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
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.