Dieser Artikel wurde maschinell übersetzt.

Programmiererpraxis

Inside SQLite

Ted Neward

Beispielcode herunterladen

Ted NewardIm Einklang mit dem Design des Problems ist es Zeit zu den Wurzeln von SQL und relationalen Datenbanken zurückzukehren.Natürlich würden daher etwas über die SQL Server, etwas über Ihre neuen Feature oder die Leistung der Verbesserungen oder whatnot, Schreiben apropos scheinen, aber Meine Formatvorlage ist einfach nicht.Verstehen Sie nicht mir falsch, SQL Server ist eine große Datenbank und für diesen “ big Bügeleisen ” Organisationsklassen-Szenarios dringend empfohlen, jedoch nicht jedes Problem erfordert (wie ein Freund einmal ausgedrückt) eine “ big Honkin ’ zentrale Datenbank.

In der Tat Entwickler lange verwendet haben relationale Datenbanken lediglich als einen Ort zum nächsten Mal “ Spielereien ablegen ” – Dinge wie z. B. Konfiguration Optionen, Benutzereinstellungen, Werte für die Internationalisierung und so weiter.Obwohl es in einigen Fällen praktisch, diese in einem zentralen SQL Server-Instanz in einigen Fällen ist besonders in rich Client-Szenarios (insbesondere Microsoft Silverlight oder Windows Telefon 7 rich Clientszenarien und) verwalten eine Konstante Verbindung zurück zu der SQL Server-Instanz ist nicht durchführbar bestenfalls und oft nur flat-out unmöglich.

Entwickler nicht notwendigerweise um die Leistungsfähigkeit und Flexibilität einer relationalen Datenbank zu erteilen möchten, aber auch SQL Server Express ist manchmal ein zu hoher installieren.Was ist geschehen?

Gehen Sie Licht, natürlich: SQLite präzise sein.

Einführung in SQLite

Wie beschrieben, die von der Website (sqlite.org), “ SQLite ist ein Software-Bibliothek, die eine eigenständige, serverlose, NULL-Konfiguration, transaktionale SQL-Datenbank-Engine. ” Die wichtigsten Elemente in dieser Anweisung drehen sich um das das Nomen “ Bibliothek ”. Im Gegensatz zu SQL Server, der eine clientseitige Assembly zum Senden von Anforderungen an einen Server für die Analyse und die Ausführung verwendet, lebt SQLite vollständig innerhalb der Clientprozess somit “ eingebettete ” Datenbank.Der laufenden Speicherbedarf einer SQLite Datenbank während der Verwendung ist eine einzelne Datei irgendwo auf dem Client-Dateisystem gespeicherten und in der Regel ist die Installationsbedarf gleichermaßen klein.

Die SQLite Datenbank wird für alle diese bemerkenswert funktionsreiche, darin, dass er die meisten minus (auf der Website des SQLite ausführlicher beschrieben) ein paar Dinge wie RIGHT oder FULL OUTER JOIN, ALTER TABLE die SQL-92-Spezifikation unterstützt einige auslösen, Support, GRANT/REVOKE und das Schreiben in Sichten.Beeindruckende ist wie viel unterstützt z. B. Transaktionen und eine Vielzahl von Datentypen.Obwohl es wahrscheinlich außerhalb der Glaubwürdigkeit zu erwarten, dass eine SQL Server-Datenbankschemas, SQLite ohne Änderung port wird, ist sinnvoll, davon ausgehen relativ einfach (d. h. nicht nutzen der SQL Server-spezifischen Typen oder Funktionen) Schema wird mit minimaler Probleme beim Portieren.Auf diese Weise SQLite ideal für Szenarios, in denen nur eine “ einfache SQL ” erforderlich ist.

Für den Fall, dass Bedenken hinsichtlich Ihrer Anwendbarkeit oder Stabilität sind, macht SQLite langsam seinen Weg in einer Vielzahl von Umgebungen “ lightweight ” – bereits offenbar in Mozilla Firefox-Browser (für HTML 5-Unterstützung) als auch die Umgebungen Symbian, iOS und Android u. a..Mit anderen Worten, dies ist wie die “ andere Hälfte ” die Entwicklung weltweit (d. h. nicht-­ Microsoft-zentrierten) unterstützt die einfache Datenbank, die.SQLite weiterhin die fortlaufende Entwicklung und Fehler beheben, wodurch eine relativ sichere Wette als minimale SQL-Modul zu genießen.

Natürlich wäre keine Datenbank vollständig ohne eine Art von Administrator-Oberfläche und SQLite disappoint nicht.Es hat eine Befehlszeilenkonsole Tool zum Aufrufen und Bearbeiten der SQLite Datenbanken – aber, die möglicherweise Ihre Sysadmin nicht allzu viel beeindrucken.Glücklicherweise die open Source Community verfügt über eine Reihe von SQLite Tools zur Verfügung (eine lange Liste von Ihnen ist auf der Website des SQLite), aber wenn Sie nur ein schnelles Query Analyzer-ähnliche-Tool versuchen SQLite Administrator, ein kostenloses Tool zum sqliteadmin.orbmu2k.de-Download zur Verfügung.

Goin ’ native

SQLite wurde vom Anfang vorgesehen, um eine Datenbank für Entwickler systemeigener Code sein, weshalb es als eine systemeigene C/C++-DLL implementiert ist.Dieser systemeigene-Geschmacksrichtung SQLite ist eine gute und ein Fluch: blessing, darin, dass es sich ein Großteil der Aufwand (z. B., der im Netzwerk erneut an den Server und das Durchlaufen der) schneidet aus die Gesamtzeit, die eine bestimmte SQL-Anweisung ausführen, aber curse insofern, da die ursprüngliche SQLite Datenbank eine systemeigene C/C++-DLL handelt, die aus einer Microsoft .NET Framework-basierte Anwendung darauf erhalten eine Herausforderung darstellen kann.

Glücklicherweise erkennt intelligenter .NET Framework-Entwickler den Zugriff auf eine systemeigene DLL ist eigentlich nur eine Übung in P/Invoke-Deklarationen, und es ist relativ einfach, erstellen eine Wrapperklasse um die systemeigenen Deklarationen in der DLL SQLite verfügbar gemacht.In der Tat für die Grundlagen wie bei so vielen Dingen in der open Source Community bereits wurde erfolgt; Navigieren zur switchonthecode.com/tutorials/csharp-tutorial-writing-a-dotnet-wrapper-for-sqlite von , und wir feststellen, dass ein Workingset von P/Invoke-Deklarationen, die bereits nach unten angeordnet in Abbildung 1 dargestellt.

Abbildung 1 P/Invoke-Deklarationen

namespace SQLiteWrapper
{
  public class SQLiteException : Exception
  {
    public SQLiteException(string message) :
      base(message)
      { }
  }

  public class SQLite
  {
    const int SQLITE_OK = 0;
    const int SQLITE_ROW = 100;
    const int SQLITE_DONE = 101;
    const int SQLITE_INTEGER = 1;
    const int SQLITE_FLOAT = 2;
    const int SQLITE_TEXT = 3;
    const int SQLITE_BLOB = 4;
    const int SQLITE_NULL = 5;

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_open")]
      static extern int sqlite3_open(string filename, out IntPtr db);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_close")]
      static extern int sqlite3_close(IntPtr db);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_prepare_v2")]
      static extern int sqlite3_prepare_v2(IntPtr db, string zSql,
        int nByte, out IntPtr ppStmpt, IntPtr pzTail);
    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_step")]
      static extern int sqlite3_step(IntPtr stmHandle);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_finalize")]
      static extern int sqlite3_finalize(IntPtr stmHandle);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_errmsg")]
      static extern string sqlite3_errmsg(IntPtr db);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_count")]
      static extern int sqlite3_column_count(IntPtr stmHandle);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_origin_name")]
      static extern string sqlite3_column_origin_name(
        IntPtr stmHandle, int iCol);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_type")]
      static extern int sqlite3_column_type(IntPtr stmHandle, int iCol);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_int")]
      static extern int sqlite3_column_int(IntPtr stmHandle, int iCol);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_text")]
      static extern string sqlite3_column_text(IntPtr stmHandle, int iCol);

    [DllImport("sqlite3.dll", EntryPoint = "sqlite3_column_double")]
      static extern double sqlite3_column_double(IntPtr stmHandle, int iCol);
  }
}

Die High Fidelity von P/Invoke von C/C++-APIs ist dies relativ einfach – die SQLite-API verwendet einen unformatierten Zeiger auf die Datenbank selbst, darstellen, die P/Invoke als einen System.IntPtr sieht, und hin so oft die SQLite-API verwendet einen Zeiger auf ein Int als Parameter, damit es den Inhalt, der durch P/Invoke, mit dem C#-Schlüsselwort “ out ” beschrieben ändern kann. (Weitere Informationen über P/Invoke Siehe pinvoke.codeplex.com-.)

Ich werde Sie SQLite-Website für den Großteil der Details zur Verwendung der API SQLite bezeichnen, jedoch ein kurzer Blick auf eine Datenbank zu öffnen, führen Sie eine Abfrage, und schließen Sie die Datenbank wie würde zeigen Ihnen etwa Abbildung 2 .

Abbildung 2 Öffnen einer Datenbank, das Ausführen einer Abfrage, und schließen die Datenbank

static void NativeMain()
 {
   // Open the database--db is our "handle" to it
   IntPtr db;
   if (SQLiteNative.sqlite3_open(@"cities.sqlite", out db) 
     == SQLiteNative.SQLITE_OK)
     {
       // Prepare a simple DDL "CREATE TABLE" statement
       string query = 
         "CREATE TABLE City " + 
         "(name TEXT, state TEXT, population INTEGER)";
       IntPtr stmHandle;
       if (SQLiteNative.sqlite3_prepare_v2(db, query, query.Length,
         out stmHandle, IntPtr.Zero) != SQLiteNative.SQLITE_OK)
       {
         // Something went wrong--find out what
         var err = SQLiteNative.sqlite3_errmsg(db);
       }
       if (SQLiteNative.sqlite3_step(stmHandle) != 
         SQLiteNative.SQLITE_DONE)
       {
         // Something went wrong--find out what
         var err = SQLiteNative.sqlite3_errmsg(db);
       }
       if (SQLiteNative.sqlite3_finalize(stmHandle) != 
         SQLiteNative.SQLITE_OK)
       {
         // Something went wrong--find out what
         var err = SQLiteNative.sqlite3_errmsg(db);
       }

     // ... Now that we've created a table, we can insert some
     // data, query it back and so on

     // Close the database back up
     SQLiteNative.sqlite3_close(db);
     }
  }

Ich bin Feelin ’ mighty Low

Die besonders auffallend diese API ist, dass es ein wenig auf der Seite auf niedriger Ebene ist. Wenn Sie eine alte C++-Hack, wie ich sind, kann dies eine gute Sache, erteilen uns eine wunderbare Gelegenheit zum reminisce über das gute alte Tage, wenn Männer Männer, Arbeitsspeicher wurde die Verwaltung von hand und Frauen swooned am Cocktailparty Parteien über unsere Halloween-Motiven Dokumentteile wenig nach unten untamed Zeiger im Wilds von Windows 95 … für den Rest der folgenden C#-Whipper-Snappers, diese Johnny-Come-Latelys, produktive Arbeit tatsächlich möchten dies kann jedoch etwas zu Low ist, auf dem Boden so zu Prinzip wieder sein. Was benötigt wird, ist eine gute Abstraktion Wrapper für diese API erleichtern überschaubarer und ausgeschnittenen nach unten auf die Anzahl der Zeilen Code erforderlich, um es zu verwenden.

Nachbereiten dies in einer einzelnen Klasse ist nicht schwer, besonders da System.Data einige guten Klassen zur Verfügung stellt, die größte Teil der Interaktion der Benutzer-API behandeln kann. Zeigt die vollständigen Details die Wrapper-Klasse namens SQLite, etwas zu längeren hier einbezogen ist, aber die Deklarationen in Abbildung 3 dargestellten bieten eine ziemlich klar Hinweis auf wie hat es verwendet werden soll.

Abbildung 3 Deklarationen von der Wrapperklasse SQLite

public class SQLite : IDisposable
  {
    private IntPtr _db; //pointer to SQLite database
    private bool _open; //whether or not the database is open

    /// <summary>
    /// Opens or creates SQLite database with the specified path
    /// </summary>
    /// <param name="path">Path to SQLite database</param>
    public void OpenDatabase(string path);

    /// <summary>
    /// Closes the SQLite database
    /// </summary>
    public void CloseDatabase();

    /// <summary>
    /// Executes a query that returns no results
    /// </summary>
    /// <param name="query">SQL query to execute</param>
    public void ExecuteNonQuery(string query);

    /// <summary>
    /// Executes a query and stores the results in
    /// a DataTable
    /// </summary>
    /// <param name="query">SQL query to execute</param>
    /// <returns>DataTable of results</returns>
    public DataTable ExecuteQuery(string query);
  }

Verwenden es, würde dann wie im Beispiel aussehen in Abbildung 4 .

Abbildung 4 mithilfe der Wrapperklasse SQLite

static void NativeWrapperMain()
  {
    using (SQLite db = new SQLite("persons.sqlite"))
    {
      db.ExecuteNonQuery("CREATE Table Persons " +
        "(first TEXT, last TEXT, age INTEGER)");

      db.ExecuteNonQuery("INSERT INTO Persons (first, last, age) " +
        "VALUES ('Aaron', 'Erickson', 38)");
      db.ExecuteNonQuery("INSERT INTO Persons (first, last, age) " +
        "VALUES ('Rick', 'Minerich', 29)");
      db.ExecuteNonQuery("INSERT INTO Persons (first, last, age) " +
        "VALUES ('Talbott', 'Crowell', 35)");

      DataTable table = db.ExecuteQuery("SELECT * FROM Persons");

      foreach (DataRow row in table.Rows)
      {
        Console.WriteLine("{0} {1} {2}", row[0], row[1], row[2]);
      }
    }
  }

Stehen deutlich mehr Operationen, die die Wrapperklasse SQLite in Abbildung 4 hinzugefügt werden konnte, aber er hat bereits die einfachste erforderlichen Funktionalität erhalten, Danke Teil der hervorragenden Datenbank agnostischen Natur der zentralen DataTable, DataRow/DataColumn-Klassen im System.Data.

Abstraktionen, Abstraktionen

In mancher Hinsicht ist die SQLite Datenbank nutzen das Low-Level-Design und Implementierung – integrierbare bedeutet, dass die Verwendung von “ reibungsloses ” beteiligt ist sehr gering. Fügen Sie Wrapper-Klassen hinzu, stellen Sie sicher die DLL SQLite irgendwo auf das Programm zugreifen können (in der Regel durch Speichern in das Verzeichnis mit der ausführbaren Datei) und nun Sie SQL-Anweisungen, wie ein Situationen schreiben. Vorausgesetzt, dass das ist, was natürlich tun soll.

Aber es ist wahrscheinlich, dass deutliche Mehrheit der .NET Framework-Entwickler sind entweder aus der Praxis bei der Verwaltung von einer SQL-Datenbank vollständig “ von hand ” über Konsolen-APIs, die nie wusste wie es oder nur die Welt bleiben möchten. Moderne .NET Framework-Umgebung enthält diese eine Vielzahl von Tools zum Erstellen und Verwalten von relationalen Schemas zurück, die dieser manuelle Ansatz positiv primitiven ist und, noch wichtiger ist, Unproduktiv.

Darüber hinaus Microsoft verbracht hat bereits Aufwand eine API, die effektiv die meisten Dinge beschreibt, die möchte, dass ein Programmierer anhand einer relationalen Datenbank führen Sie, erstellen und eine Vielzahl von Tools (LINQ to SQL, Entity Framework und sogar der Visual Studio-Designer) beruhen,-API. Ich finden, natürlich, ADO.NET und dessen Providermodell. Nicht über die Fähigkeit zur Folie SQLite “ unter ” ADO.NET bedeutet, dass alle diese Coolness steht für den Entwickler mit SQLite und, erscheint eine sehr wichtige Schwierigkeit werden. Die Lösung ist, um ein ADO.NET-Anbieter für SQLite zu erstellen.

Wie wir bereits herausgefunden haben, ist eine der schön Aspekte von open Source-Community ist eine sehr hohe Wahrscheinlichkeit, dass alles, was Sie suchen sollen, jemand hat Sie bereits getan, und dies gilt. System.Data.SQLite, unter system.data.sqlite.org/index.html/doc/trunk/www/downloads.wiki, heruntergeladen ist ein vollständiger ADO.NET 3.5-Anbieter, d. h. alles, was Entwickler für eine relationale Datenbank traditionellen Client/Server-Anbieter zur Verfügung stehen zur Verfügung, um die SQLite ist Unterstützung für Entwickler, einschließlich Visual Studio-Designer sowie LINQ und Entity Framework.

Verwenden von System.Data.SQLite ist ziemlich einfach. Nehmen Sie den Download (entweder die Quelle, daher können Sie selbst erstellen und im Code wie alles funktioniert um herumzustöbern – Dies ist ein gutes Beispiel, wenn Sie neugierig sind, wie ein ADO.NET-Anbieter erstellen aus zu arbeiten, oder nehmen Sie einfach die Binärdateien, wenn Sie schnell auf “ done ” mehr erhalten möchten). Legen Sie die Bits an einer beliebigen Stelle auf Ihrer Festplatte, Verweis System.Data.SQLite.dll aus dem Projekt und der Nutzungsdauer ist gutes. Überrascht nicht, dass die API-Klassen in System.Data.SQLite live, und sobald Sie verwiesen haben, können Sie guten alten ADO.NET-Code anhand der Datenbank schreiben, wie in Abbildung 5 .

Abbildung 5 verwenden System.Data.SQLite

static void ManagedWrapperMain()
{
  var connStr = new SQLiteConnectionStringBuilder() 
    { DataSource = "persons.sqlite" };
  using (SQLiteConnection conn = new SQLiteConnection(connStr.ToString()))
  {
    conn.Open();
    SQLiteCommand cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT COUNT(*) FROM Persons";
    var ct = cmd.ExecuteScalar();
    Console.WriteLine("Count = {0}", ct);

    cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT * FROM Persons";
    SQLiteDataReader reader = cmd.ExecuteReader();
    DataTable dt = new DataTable();
    dt.Load(reader);
    foreach (DataRow row in dt.Rows)
    {
      Console.WriteLine("{0} {1} {2}", row[0], row[1], row[2]);
    }
  }
}

So weit, so gut. Wenn der Code eines Visual Studio 2005 oder 2008-Projekts ausgeführt wird, funktioniert alles flawlessly. Doch wenn der Code von Visual Studio 2010 ausgeführt wird, ein Fehler kommt, Inanspruchnahme “ unbehandelte Ausnahme: System.IO.FileLoadException: Assembly im gemischten Modus wird gegen "v2.0.50727" von der Common Language Runtime-Version erstellt und kann nicht ohne zusätzliche Konfigurationsinformationen 4.0 zur Laufzeit geladen werden. ” Eine Assembly im gemischten Modus für diejenigen, die den Begriff vor, noch nicht zu hören ist eine Assembly, die verwalteten Microsoft Intermediate Language und systemeigene x 86 Assemblyanweisungen enthält. Aus diesem Grund ist natürlich nicht gut, auf zwei Ebenen – eines, das offensichtliche Problem ist den Code ausgeführt wird, erhalten wir müssen und zwei, wenn diese eine Assembly im gemischten Modus ist, geht es um einige Probleme bei SQLite in anderen Umgebungen, wie z. B. ASP.NET zu erstellen.

Das erste Problem ist einfach gelöst, indem eine app.config-Datei, die die CLR 4.0 zum Laden der Assembly im gemischten Modus:

<?xml version="1.0"encoding="utf-8" ?>
<configuration>
  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0"/>
  </startup>
</configuration>

Das größeres Problem ist, dass eine Reihe von Umgebungen Don gemischten Assemblys unterstützen und in keinem Fall eine bestimmte Aesthetic beteiligten hier ist. Eine Vielzahl von Gründen wäre eine vollständig verwaltete Lösung vorzuziehen, aber wäre, da die DLL SQLite systemeigenen Code, schwierig sein. Was wäre schön ist ein Port, der die SQLite Codebasis zu c#, um das ursprüngliche C wie möglich gehalten.

Alle verwalteten

Noch einmal die open Source Community bietet, wenn Sie aufgefordert werden, und in diesem Fall ein Projekt namens zur Verfügung “ c#-SQLite, ” code.google.com/p/csharp-sqlite-zur Verfügung. Er scheinbar gestartet als “ Übung die Programmiersprache c# erlernen ” durch Portieren von Code über, und zugeordnete Wiki hat einige Erläuterungen, was der Autor, hat um den Port zu verwalten, aber die Upshot besteht darin, dass wir jetzt genau, was wir brauchten: eine vollständig verwaltete Version der SQLite.

Es erfordert die Projekts Quellen downloaden, das Öffnen des Projekts und deaktiviert ein Buildvorgang gestartet. Wie eine Reihe von open Source-Projekten c# - SQLite besteht aus mehreren Projekten jedoch jeweils in einer eigenen Datei Lösung eingeschlossen ist, müssen Sie möglicherweise mehr als eine Projektmappe zu öffnen. (Oder nur aus den Build über die Befehlszeile mit MSBuild starten – was auch immer am besten funktioniert.)

Nachdem es erstellt wurde, fügen Sie der c# - SQLite Assembly (Community.C ­­ scharf ­ SQLite) zur Unterstützung von ADO.NET und dem Projekt hinzufügen der c# - sowie SQLite Client-Assembly (Community.CsharpSqlite.SQLiteClient.dll). Noch einmal stehen den vollständigen Funktionsumfang von SQLite an uns über ein ADO.NET-Anbieter, so dass wir fast genauen denselben Code gezeigt frühere (siehe Abbildung 6 ) schreiben können.

Abbildung 6 mit c#-SQLite

Static void AllManagedMain()
{
  SqliteConnection conn = 
    New SqliteConnection(@"Version=3,uri=file:persons.sqlite");
  conn.Open();
  try
  {
    SqliteCommand cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT COUNT(*) FROM Persons";
    var ct = cmd.ExecuteScalar();
    Console.WriteLine("Count = {0}", ct);

    cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT * FROM Persons";
    SqliteDataReader reader = cmd.ExecuteReader();
    while (reader.Read())
    {
      Console.WriteLine("{0} {1} {2}", reader[0], reader[1], reader[2]);
    }
  }
  finally
  {
    conn.Close();
  }
}

Beachten Sie, wie die APIs mit Version im gemischten Modus weiter oben nahezu identisch sind (nur die Klassennamen geändert haben, und selbst dann tatsächlich nur eine Frage der Fall ist: “ SQLite ” Vs. “ Sqlite ” als Präfix, z. B.), aber jetzt erhalten wir alle die Anpassungsgüte SQLite ohne potenzielle Sicherheitsprobleme (sofern vorhanden) einer DLL im einheitlichen Modus.

Einschränkungen

Trotz der hervorragenden Art SQLite ist es wichtig, Ihre Grenzen zu verstehen, ist die Entscheidung zwischen der Verwendung von SQLite und SQL Server alle Maß Nerven vorgenommen werden. SQLite geht nicht auf die Features von SQL Server bieten – weit aus. Die SQLite Datenbank möchten nicht auch Entwickler, die zum Verwenden von mehreren Threads, viel weniger von mehreren Threads darauf zugreifen. In der Tat ist es durchaus sagen, wenn zwei Programmen gleichzeitig Zugriff auf eine SQLite Datenbank soll, es ist wahrscheinlich Zeit auf eine SQL Server-Instanz (Express oder anderweitig) aktualisieren.

Principal Bereiche des SQLite “ Win ” werden in vielen der gleichen Bereiche, mit denen Access-Dateien belegen, mit der Syntax SQL-92 in der Nähe abzuschließen, zusammen mit der Fähigkeit zum Lesen von anderen Umgebungen (Python, Perl und So weiter) verwendeten Datenbankdateien zu sichern. Verwendung von Silverlight oder Telefon-Clients ist auch eine sehr interessante Bereich, besonders für die lokale Speicherung – das Festhalten einer SQLite Datenbank in Silverlight isolierter Speicher würde bieten Entwicklern einen portablen (dass es mit dem Silverlight-Code übertragen werden kann) Datenbank, in der lokale Daten, z. B. speichern. Verwenden Sie überlegt und SQLite Rundet aus einer relationalen Datenbank Kontinuum der Funktionalität-Weight-Optionen.

Auch hier ist ein bestimmtes Thema, das Sie anzeigen durchsuchte möchten, nicht hesitate mir eine Notiz löschen. Dies ist schließlich Ihre Kolumne.

Viel Spaß beim Programmieren!

Ted Neward ein Principal mit Neward ist & Associates, eine unabhängige fest spezialisiert .NET Framework und der Java-Plattform Unternehmenssysteme. Er hat mehr als 100 Artikel geschrieben, ist ein C#-MVP und ein INETA-Sprecher und hat mehrere Bücher allein und in Zusammenarbeit mit anderen geschrieben, darunter das in Kürze erscheinende „Professional F# 2.0“ (Wrox). Er berät und hilft regelmäßig. Erreichen Sie ihn unter ted@tedneward.com -und Lesen Sie seinen Blog unter blogs.tedneward.com-.