C# Language
Verwenden von SQLite in C #

Einfaches CRUD mit SQLite in C # erstellen

Zunächst müssen wir unserer Anwendung die Unterstützung von SQLite hinzufügen. Dafür gibt es zwei Möglichkeiten

• Laden Sie die DLL für Ihr System von der SQLite-Downloadseite herunter und fügen Sie sie manuell zum Projekt hinzu
• SQLite-Abhängigkeit über NuGet hinzufügen

Wir machen es auf die zweite Weise

Öffnen Sie zuerst das NuGet-Menü

und suchen Sie nach System.Data.SQLite , wählen Sie es aus und klicken Sie auf Installieren

Die Installation kann auch über die Package Manager Console mit durchgeführt werden

PM> Install-Package System.Data.SQLite

Oder nur für Kernfunktionen

PM> Install-Package System.Data.SQLite.Core 

Das wars für den Download, also können wir gleich mit dem Codieren beginnen.

Erstellen Sie zunächst eine einfache SQLite-Datenbank mit dieser Tabelle und fügen Sie sie dem Projekt als Datei hinzu

CREATE TABLE User(
  Id INTEGER PRIMARY KEY AUTOINCREMENT,
  FirstName TEXT NOT NULL,
  LastName TEXT NOT NULL
);

Vergessen Sie auch nicht, die Copy to Output Directory- Eigenschaft der Datei je nach Ihren Anforderungen auf Copy zu setzen, wenn Sie von Copy immer neuer sind

Erstellen Sie eine Klasse mit dem Namen User, die als Basiseinheit für unsere Datenbank dient

private class User
{
    public string FirstName { get; set; }
    public string Lastname { get; set; }
}

Wir schreiben zwei Methoden für die Abfrageausführung, zuerst eine für das Einfügen, Aktualisieren oder Entfernen aus der Datenbank

private int ExecuteWrite(string query, Dictionary<string, object> args)
{
    int numberOfRowsAffected;

    //setup the connection to the database
    using (var con = new SQLiteConnection("Data Source=test.db"))
    {
        con.Open();
        
        //open a new command
        using (var cmd = new SQLiteCommand(query, con))
        {
            //set the arguments given in the query
            foreach (var pair in args)
            {
                cmd.Parameters.AddWithValue(pair.Key, pair.Value);
            }

            //execute the query and get the number of row affected
            numberOfRowsAffected = cmd.ExecuteNonQuery();
        }

        return numberOfRowsAffected;
    }
}

und der zweite zum Lesen aus der Datenbank

private DataTable Execute(string query)
{
    if (string.IsNullOrEmpty(query.Trim()))
        return null;

    using (var con = new SQLiteConnection("Data Source=test.db"))
    {
        con.Open();
        using (var cmd = new SQLiteCommand(query, con))
        {
            foreach (KeyValuePair<string, object> entry in args)
            {
                cmd.Parameters.AddWithValue(entry.Key, entry.Value);
            }

            var da = new SQLiteDataAdapter(cmd);

            var dt = new DataTable();
            da.Fill(dt);

            da.Dispose();
            return dt;
        }
    }
}

Nun lasst uns in unsere CRUD- Methoden einsteigen

Benutzer hinzufügen

private int AddUser(User user)
{
    const string query = "INSERT INTO User(FirstName, LastName) VALUES(@firstName, @lastName)";

    //here we are setting the parameter values that will be actually 
    //replaced in the query in Execute method
    var args = new Dictionary<string, object>
    {
        {"@firstName", user.FirstName},
        {"@lastName", user.Lastname}
    };

    return ExecuteWrite(query, args);
}

Benutzer bearbeiten

private int EditUser(User user)
{
    const string query = "UPDATE User SET FirstName = @firstName, LastName = @lastName WHERE Id = @id";

    //here we are setting the parameter values that will be actually 
    //replaced in the query in Execute method
    var args = new Dictionary<string, object>
    {
        {"@id", user.Id},
        {"@firstName", user.FirstName},
        {"@lastName", user.Lastname}
    };

    return ExecuteWrite(query, args);
}

Benutzer löschen

private int DeleteUser(User user)
{
    const string query = "Delete from User WHERE Id = @id";

    //here we are setting the parameter values that will be actually 
    //replaced in the query in Execute method
    var args = new Dictionary<string, object>
    {
        {"@id", user.Id}
    };

    return ExecuteWrite(query, args);
}

Benutzer nach Id

private User GetUserById(int id)
{
    var query = "SELECT * FROM User WHERE Id = @id";

    var args = new Dictionary<string, object>
    {
        {"@id", id}
    };

    DataTable dt = ExecuteRead(query, args);

    if (dt == null || dt.Rows.Count == 0)
    {
        return null;
    }

    var user = new User
    {
        Id = Convert.ToInt32(dt.Rows[0]["Id"]),
        FirstName = Convert.ToString(dt.Rows[0]["FirstName"]),
        Lastname = Convert.ToString(dt.Rows[0]["LastName"])
    };

    return user;
}

Abfrage ausführen

using (SQLiteConnection conn = new SQLiteConnection(@"Data Source=data.db;Pooling=true;FailIfMissing=false"))
{
    conn.Open();
    using (SQLiteCommand cmd = new SQLiteCommand(conn))
    {
       cmd.CommandText = "query";
       using (SqlDataReader dr = cmd.ExecuteReader())
       {
           while(dr.Read())
           {
               //do stuff
           }
       }
    }
}

Anmerkung : Durch das Festlegen von FailIfMissing auf true wird die Datei data.db falls diese fehlt. Die Datei ist jedoch leer. Daher müssen alle erforderlichen Tabellen neu erstellt werden.