Utilisation de ADO.NET avec Xamarin.iOS

Xamarin offre une prise en charge intégrée de la base de données SQLite disponible sur iOS, exposée à l’aide d’une syntaxe de type ADO.NET familière. L’utilisation de ces API vous oblige à écrire des instructions SQL qui sont traitées par SQLite, telles que CREATE TABLEles instructions , INSERT et SELECT .

Références d'assembly

Pour utiliser l’accès à SQLite via ADO.NET vous devez ajouter System.Data des références et Mono.Data.Sqlite à votre projet iOS, comme indiqué ici (pour des exemples dans Visual Studio pour Mac et Visual Studio) :

Visual Studio pour Mac
Visual Studio

Références d’assembly dans Visual Studio pour Mac

Cliquez avec le bouton droit sur Références > Modifier les références... puis cliquez pour sélectionner les assemblys requis.

À propos de Mono.Data.Sqlite

Nous allons utiliser la Mono.Data.Sqlite.SqliteConnection classe pour créer un fichier de base de données vide, puis pour instancier des SqliteCommand objets que nous pouvons utiliser pour exécuter des instructions SQL sur la base de données.

Création d’une base de données vide : appelez la CreateFile méthode avec un chemin de fichier valide (par exemple, accessible en écriture). Vous devez case activée si le fichier existe déjà avant d’appeler cette méthode. Sinon, une nouvelle base de données (vide) sera créée au-dessus de l’ancienne et les données de l’ancien fichier seront perdues :

Mono.Data.Sqlite.SqliteConnection.CreateFile (dbPath);

Notes

La dbPath variable doit être déterminée selon les règles décrites plus haut dans ce document.
Création d’une connexion de base de données : une fois le fichier de base de données SQLite créé, vous pouvez créer un objet de connexion pour accéder aux données. La connexion est construite avec une chaîne de connexion qui prend la forme de Data Source=file_path, comme illustré ici :
```
var connection = new SqliteConnection ("Data Source=" + dbPath);
connection.Open();
// do stuff
connection.Close();
```
Comme mentionné précédemment, une connexion ne doit jamais être réutilisée sur différents threads. En cas de doute, créez la connexion en fonction des besoins et fermez-la lorsque vous avez terminé . mais veillez à le faire plus souvent que nécessaire aussi.
Création et exécution d’une commande de base de données : une fois que nous avons une connexion, nous pouvons exécuter des commandes SQL arbitraires sur celle-ci. Le code ci-dessous montre une instruction CREATE TABLE en cours d’exécution.
```
using (var command = connection.CreateCommand ()) {
    command.CommandText = "CREATE TABLE [Items] ([_id] int, [Symbol] ntext, [Name] ntext);";
    var rowcount = command.ExecuteNonQuery ();
}
```

Lorsque vous exécutez SQL directement sur la base de données, vous devez prendre les précautions normales pour ne pas effectuer de requêtes non valides, telles que la tentative de création d’une table qui existe déjà. Effectuez le suivi de la structure de votre base de données afin de ne pas provoquer une exception SqliteException telle que « la table d’erreurs SQLite [Éléments] existe déjà ».

Accès aux données de base

L’exemple de code DataAccess_Basic pour ce document ressemble à ceci lors de l’exécution sur iOS :

Exemple de ADO.NET iOS

Le code ci-dessous montre comment effectuer des opérations SQLite simples et affiche les résultats sous forme de texte dans la fenêtre main de l’application.

Vous devez inclure ces espaces de noms :

using System;
using System.IO;
using Mono.Data.Sqlite;

L’exemple de code suivant montre une interaction de base de données entière :

Création du fichier de base de données
Insertion de données
Interrogation des données

Ces opérations apparaissent généralement à plusieurs endroits dans votre code. Par exemple, vous pouvez créer le fichier de base de données et les tables lorsque votre application démarre pour la première fois et effectuer des lectures et des écritures de données dans des écrans individuels dans votre application. Dans l’exemple ci-dessous, ont été regroupés en une seule méthode pour cet exemple :

public static SqliteConnection connection;
public static string DoSomeDataAccess ()
{
    // determine the path for the database file
    string dbPath = Path.Combine (
        Environment.GetFolderPath (Environment.SpecialFolder.Personal),
        "adodemo.db3");

    bool exists = File.Exists (dbPath);

    if (!exists) {
        Console.WriteLine("Creating database");
        // Need to create the database before seeding it with some data
        Mono.Data.Sqlite.SqliteConnection.CreateFile (dbPath);
        connection = new SqliteConnection ("Data Source=" + dbPath);

        var commands = new[] {
            "CREATE TABLE [Items] (_id ntext, Symbol ntext);",
            "INSERT INTO [Items] ([_id], [Symbol]) VALUES ('1', 'AAPL')",
            "INSERT INTO [Items] ([_id], [Symbol]) VALUES ('2', 'GOOG')",
            "INSERT INTO [Items] ([_id], [Symbol]) VALUES ('3', 'MSFT')"
        };
        // Open the database connection and create table with data
        connection.Open ();
        foreach (var command in commands) {
            using (var c = connection.CreateCommand ()) {
                c.CommandText = command;
                var rowcount = c.ExecuteNonQuery ();
                Console.WriteLine("\tExecuted " + command);
            }
        }
    } else {
        Console.WriteLine("Database already exists");
        // Open connection to existing database file
        connection = new SqliteConnection ("Data Source=" + dbPath);
        connection.Open ();
    }

    // query the database to prove data was inserted!
    using (var contents = connection.CreateCommand ()) {
        contents.CommandText = "SELECT [_id], [Symbol] from [Items]";
        var r = contents.ExecuteReader ();
        Console.WriteLine("Reading data");
        while (r.Read ())
            Console.WriteLine("\tKey={0}; Value={1}",
                              r ["_id"].ToString (),
                              r ["Symbol"].ToString ());
    }
    connection.Close ();
}

Requêtes plus complexes

Étant donné que SQLite permet l’exécution de commandes SQL arbitraires sur les données, vous pouvez exécuter les instructions CREATE, INSERT, UPDATE, DELETE ou SELECT que vous souhaitez. Vous pouvez en savoir plus sur les commandes SQL prises en charge par SQLite sur le site web Sqlite. Les instructions SQL sont exécutées à l’aide de l’une des trois méthodes sur un objet SqliteCommand :

ExecuteNonQuery : généralement utilisé pour la création de tables ou l’insertion de données. La valeur de retour pour certaines opérations est le nombre de lignes affectées, sinon il s’agit de -1.
ExecuteReader : utilisé lorsqu’une collection de lignes doit être retournée en tant que SqlDataReader .
ExecuteScalar : récupère une valeur unique (par exemple un agrégat).

EXECUTENONQUERY

Les instructions INSERT, UPDATE et DELETE retournent le nombre de lignes affectées. Toutes les autres instructions SQL retournent -1.

using (var c = connection.CreateCommand ()) {
    c.CommandText = "INSERT INTO [Items] ([_id], [Symbol]) VALUES ('1', 'APPL')";
    var rowcount = c.ExecuteNonQuery (); // rowcount will be 1
}

EXECUTEREADER

La méthode suivante montre une clause WHERE dans l’instruction SELECT. Étant donné que le code crée une instruction SQL complète, il doit veiller à placer les caractères réservés dans une séquence d’échappement, comme le guillemet (« ») autour des chaînes.

public static string MoreComplexQuery ()
{
    var output = "";
    output += "\nComplex query example: ";
    string dbPath = Path.Combine (
        Environment.GetFolderPath (Environment.SpecialFolder.Personal), "ormdemo.db3");

    connection = new SqliteConnection ("Data Source=" + dbPath);
    connection.Open ();
    using (var contents = connection.CreateCommand ()) {
        contents.CommandText = "SELECT * FROM [Items] WHERE Symbol = 'MSFT'";
        var r = contents.ExecuteReader ();
        output += "\nReading data";
        while (r.Read ())
            output += String.Format ("\n\tKey={0}; Value={1}",
                    r ["_id"].ToString (),
                    r ["Symbol"].ToString ());
    }
    connection.Close ();

    return output;
}

La méthode ExecuteReader renvoie un objet SqliteDataReader. Outre la méthode Read présentée dans l’exemple, d’autres propriétés utiles sont les suivantes :

RowsAffected : nombre de lignes affectées par la requête.
HasRows : indique si des lignes ont été retournées.

EXECUTESCALAR

Utilisez cette option pour les instructions SELECT qui retournent une valeur unique (par exemple, un agrégat).

using (var contents = connection.CreateCommand ()) {
    contents.CommandText = "SELECT COUNT(*) FROM [Items] WHERE Symbol <> 'MSFT'";
    var i = contents.ExecuteScalar ();
}

Le ExecuteScalar type de retour de la méthode est object : vous devez caster le résultat en fonction de la requête de base de données. Le résultat peut être un entier d’une requête COUNT ou une chaîne d’une requête SELECT à colonne unique. Notez que cela est différent des autres méthodes Execute qui retournent un objet lecteur ou un nombre de lignes affectées.

Microsoft.Data.Sqlite

Il existe une autre bibliothèque Microsoft.Data.Sqlite, qui peut être installée à partir de NuGet, qui est fonctionnellement équivalente à Mono.Data.Sqlite et autorise les mêmes types de requêtes.

Il existe une comparaison entre les deux bibliothèques et certains détails spécifiques à Xamarin. Plus important pour les applications Xamarin.iOS, vous devez inclure un appel d’initialisation :

// required for Xamarin.iOS
SQLitePCL.Batteries_V2.Init();

Last updated on 2023-07-13

Partager via