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:
Adicionar uma instrução using – adicione a seguinte instrução aos arquivos C# em que o acesso a dados é necessário:
using SQLite;
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.
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
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:
- Criando o arquivo de banco de dados
- Inserindo alguns dados criando objetos e salvando-os
- 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);