Usando SQLite.NET com o Xamarin.iOS

A biblioteca SQLite.NET recomendada pelo Xamarin é um ORM básico que permite armazenar e recuperar objetos no banco de dados SQLite local em um dispositivo iOS. ORM significa Mapeamento Relacional de Objeto – uma API que permite salvar e recuperar "objetos" de um banco de dados sem gravar instruções SQL.

Uso

Para incluir a biblioteca SQLite.NET em um aplicativo Xamarin, adicione o seguinte pacote NuGet ao seu projeto:

• Nome do pacote: sqlite-net-pcl
• Autor: Frank A. Krueger
• Id: sqlite-net-pcl
• Url:nuget.org/packages/sqlite-net-pcl

Há vários pacotes SQLite diferentes disponíveis– certifique-se de escolher o correto (pode não ser o principal resultado na pesquisa).

Importante

SQLite.NET é uma biblioteca de terceiros com suporte do repositório praeclarum/sqlite-net.

Depois de ter a biblioteca de SQLite.NET disponível, siga estas três etapas para usá-la para acessar um banco de dados:

1. Adicionar uma instrução using – adicione a seguinte instrução aos arquivos C# em que o acesso a dados é necessário:

   using SQLite;
   

2. Criar um Banco de Dados em Branco – uma referência de banco de dados pode ser criada passando o caminho do arquivo do construtor da classe SQLiteConnection. Você não precisa marcar se o arquivo já existir – ele será criado automaticamente, se necessário, caso contrário, o arquivo de banco de dados existente será aberto.

   var db = new SQLiteConnection (dbPath);
   

   A variável dbPath deve ser determinada de acordo com as regras discutidas anteriormente neste documento.

3. Salvar Dados – depois de criar um objeto SQLiteConnection, os comandos de banco de dados são executados chamando seus métodos, como CreateTable e Insert desta forma:

   db.CreateTable<Stock> ();
   db.Insert (newStock); // after creating the newStock object
   

4. Recuperar Dados – para recuperar um objeto (ou uma lista de objetos) use a seguinte sintaxe:

   var stock = db.Get<Stock>(5); // primary key id of 5
   var stockList = db.Table<Stock>();
   

Exemplo de acesso a dados básicos

O código de exemplo DataAccess_Basic deste documento tem esta aparência ao ser executado no iOS. O código ilustra como executar operações de SQLite.NET simples e mostra os resultados como texto na janela main do aplicativo.

iOS

O exemplo de código a seguir mostra uma interação de banco de dados inteira usando a biblioteca SQLite.NET para encapsular o acesso ao banco de dados subjacente. Ele mostra:

1. Criando o arquivo de banco de dados
2. Inserindo alguns dados criando objetos e salvando-os
3. Consulta dos dados

Você precisará incluir estes namespaces:

using SQLite; // from the github SQLite.cs class

Isso requer que você tenha adicionado o SQLite ao seu projeto, conforme realçado aqui. Observe que a tabela de banco de dados SQLite é definida adicionando atributos a uma classe (a Stock classe) em vez de a um comando CREATE TABLE.

[Table("Items")]
public class Stock {
    [PrimaryKey, AutoIncrement, Column("_id")]
    public int Id { get; set; }
    [MaxLength(8)]
    public string Symbol { get; set; }
}
public static void DoSomeDataAccess () {
       Console.WriteLine ("Creating database, if it doesn't already exist");
   string dbPath = Path.Combine (
        Environment.GetFolderPath (Environment.SpecialFolder.Personal),
        "ormdemo.db3");
   var db = new SQLiteConnection (dbPath);
   db.CreateTable<Stock> ();
   if (db.Table<Stock> ().Count() == 0) {
        // only insert the data if it doesn't already exist
        var newStock = new Stock ();
        newStock.Symbol = "AAPL";
        db.Insert (newStock);
        newStock = new Stock ();
        newStock.Symbol = "GOOG";
        db.Insert (newStock);
        newStock = new Stock ();
        newStock.Symbol = "MSFT";
        db.Insert (newStock);
    }
    Console.WriteLine("Reading data");
    var table = db.Table<Stock> ();
    foreach (var s in table) {
        Console.WriteLine (s.Id + " " + s.Symbol);
    }
}

Usar o [Table] atributo sem especificar um parâmetro de nome de tabela fará com que a tabela de banco de dados subjacente tenha o mesmo nome que a classe (nesse caso, "Stock"). O nome real da tabela é importante se você gravar consultas SQL diretamente no banco de dados em vez de usar os métodos de acesso a dados ORM. Da mesma forma, o [Column("_id")] atributo é opcional e, se não houver uma coluna, será adicionado à tabela com o mesmo nome que a propriedade na classe .

Atributos SQLite

Os atributos comuns que você pode aplicar às suas classes para controlar como elas são armazenadas no banco de dados subjacente incluem:

• [PrimaryKey] – Esse atributo pode ser aplicado a uma propriedade de inteiro para forçá-lo a ser a chave primária da tabela subjacente. Não há suporte para chaves primárias compostas.
• [AutoIncrement] – Esse atributo fará com que o valor de uma propriedade inteira seja incrementado automaticamente para cada novo objeto inserido no banco de dados
• [Column(name)] – O name parâmetro define o nome da coluna de banco de dados subjacente.
• [Table(name)] – marca a classe como sendo capaz de ser armazenada em uma tabela SQLite subjacente com o nome especificado.
• [MaxLength(value)] – Restrinja o comprimento de uma propriedade de texto quando uma inserção de banco de dados for tentada. O consumo de código deve validar isso antes de inserir o objeto, pois esse atributo só é 'verificado' quando uma operação de inserção ou atualização de banco de dados é tentada.
• [Ignorar] – faz com que SQLite.NET ignorem essa propriedade. Isso é particularmente útil para propriedades que têm um tipo que não pode ser armazenado no banco de dados ou propriedades que modelam coleções que não podem ser resolvidas automaticamente são SQLite.
• [Exclusivo] – Garante que os valores na coluna de banco de dados subjacente sejam exclusivos.

A maioria desses atributos são opcionais. Você sempre deve especificar uma chave primária de inteiro para que as consultas de seleção e exclusão possam ser executadas com eficiência em seus dados.

Consultas mais complexas

Os seguintes métodos em SQLiteConnection podem ser usados para executar outras operações de dados:

• Inserir – adiciona um novo objeto ao banco de dados.
• Obter<T> – Tenta recuperar um objeto usando a chave primária.
• Tabela<T> – retorna todos os objetos na tabela.
• Excluir – exclui um objeto usando sua chave primária.
• Consulta<T> – executar uma consulta SQL que retorna várias linhas (como objetos).
• Execute – use esse método (e não Query ) quando não esperar linhas de volta do SQL (como instruções INSERT, UPDATE e DELETE).

Obtendo um objeto pela chave primária

SQLite.Net fornece o método Get para recuperar um único objeto com base em sua chave primária.

var existingItem = db.Get<Stock>(3);

Selecionando um objeto usando Linq

Os métodos que retornam coleções dão suporte a IEnumerable<T> para que você possa usar o Linq para consultar ou classificar o conteúdo de uma tabela. O código a seguir mostra um exemplo usando Linq para filtrar todas as entradas que começam com a letra "A":

var apple = from s in db.Table<Stock>()
    where s.Symbol.StartsWith ("A")
    select s;
Console.WriteLine ("-> " + apple.FirstOrDefault ().Symbol);

Selecionando um objeto usando SQL

Embora SQLite.Net possa fornecer acesso baseado em objeto aos seus dados, às vezes, talvez seja necessário fazer uma consulta mais complexa do que o Linq permite (ou talvez você precise de um desempenho mais rápido). Você pode usar comandos SQL com o método Query, conforme mostrado aqui:

var stocksStartingWithA = db.Query<Stock>("SELECT * FROM Items WHERE Symbol = ?", "A");
foreach (var s in stocksStartingWithA) {
    Console.WriteLine ("a " + s.Symbol);
}

Importante

Ao escrever instruções SQL diretamente, você cria uma dependência nos nomes de tabelas e colunas em seu banco de dados, que foram gerados de suas classes e seus atributos. Se você alterar esses nomes em seu código, lembre-se de atualizar todas as instruções SQL gravadas manualmente.

Excluindo um objeto

A chave primária é usada para excluir a linha, conforme mostrado aqui:

var rowcount = db.Delete<Stock>(someStock.Id); // Id is the primary key

Você pode marcar o rowcount para confirmar quantas linhas foram afetadas (excluídas nesse caso).

Usando SQLite.NET com vários threads

O SQLite dá suporte a três modos de threading diferentes: single-thread, Multi-thread e Serialized. Se você quiser acessar o banco de dados de vários threads sem nenhuma restrição, poderá configurar o SQLite para usar o modo de threading serializado . É importante definir esse modo no início do aplicativo (por exemplo, no início do OnCreate método).

Para alterar o modo de threading, chame SqliteConnection.SetConfig que está no Mono.Data.Sqlite namespace . Por exemplo, essa linha de código configura o SQLite para o modo Serializado :

using Mono.Data.Sqlite;
...
SqliteConnection.SetConfig(SQLiteConfig.Serialized);

Links Relacionados

• DataAccess Basic (exemplo)
• DataAccess Advanced (exemplo)
• Acesso a dados do Xamarin.Forms