Conectar Aplicación Xamarin forms con SqLite
Published: 2022-10-15 00:37:32

El primer paso es Instalar el nuget sqlite-net-plc

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7s1e42fcil411rmcvovk.png)

Despues creamos una clase de Conexion el cual tiene tres métodos,uno para retornar el path para asignar el nombre de base de datos, un método asíncrono y otro que no para conexiones .

```c#
using ApplicationSales.models;
using SQLite;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;


namespace ApplicationSales.services.SqlLite
{
    public class SqlLiteConexion
    {

        private string pathdb;
        public SqlLiteConexion() { }
        public string Conector()
        {
            string dbname = "db.sqlite";
            string path = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
            pathdb = Path.Combine(path, dbname);

            return pathdb;
        }

        public SQLiteConnection Conn()
        {
            SQLiteConnection conn = new SQLiteConnection(App.pedidosDB);
            return conn;
        }


        public SQLiteAsyncConnection GetConnectionAsync()
        {
            return new SQLiteAsyncConnection(App.pedidosDB);
        }

    }
}

```

En el App.cs asignamos un parametro en el constructor para asignar la base de datos a la aplicacion android.


```c#
namespace ApplicationSales
{
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class App : Application
    {
        public static string pedidosDB;
        public App(string SqlLite)
        {
        
            InitializeComponent();
            pedidosDB = SqlLite;
            MainPage = new MainPage();

        }
       
        protected override void OnStart()
        {
        }

        protected override void OnSleep()
        {
        }

        protected override void OnResume()
        {
        }
    }
}

```

Creamos el modelo de datos que tendra la tabla en mi caso use una que tenía implementada.

```c#
 public class ProductosMesa
    {
        public int? IdRegistro { get; set; }
        public int? IdProducto { get; set; }
        public int? IdPresentacion { get; set; }
        public int? IdMesa { get; set; }
        public decimal? Cantidad { get; set; }
        public int? IdPrecio { get; set; }
        public string NotasAdicionales { get; set; }
        public bool? Llevar { get; set; }
        public bool? Impreso { get; set; }
        public DateTime? DateStamp { get; set; }
        public decimal? PrecioDado { get; set; }
        public string DescCombos { get; set; }
        public string CadenaCombos { get; set; }
        public int? Ident { get; set; }
        public string Desc1 { get; set; }
        public string Desc2 { get; set; }
        public int? IdDivision { get; set; }
       
    }

```
Luego en el MainActivity de nuestro proyecto android agregamos la clase de conexion.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jmloarttzvil799fcf85.png)

```c#
 SqlLiteConexion conexion=new SqlLiteConexion();//llamamos la conexion
            Xamarin.Essentials.Platform.Init(this, savedInstanceState);
            global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
            LoadApplication(new App(conexion.Conector())); //asignamos el método conector
```


Luego creamos una interfaz para asignar los metodos que llamaremos en la clase servicio, esta solo es una manera de hacerlo, podemos incluso usar una clase abstracta o usar directamente una clase sin hacer herencia de clases.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/96o1p07oyfo94hqwbja2.png)


```c#
using ApplicationSales.models;
using DocumentFormat.OpenXml.Office2021.DocumentTasks;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Threading.Tasks;

namespace ApplicationSales.services.SqlLite
{
    public interface ISqlLiteCrud
    {
        Task<List<ProductosMesa>> GetProductos();
        void InsertarProductos(ProductosMesa producto);
        void ActualizarProductos(ProductosMesa producto);
        Task<int> BorrarProductos(ProductosMesa producto);
        void BorrarTabla();
        Task<List<ProductosMesa>> MaxRegistro();
    }
}

```

Creamos la clase donde tendremos el crud y le implementamos la interface.

```c#
using ApplicationSales.models;
using SQLite;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ApplicationSales.services.SqlLite
{
    public class SqlLiteCrud : ISqlLiteCrud
    {
        private SqlLiteConexion sqlLiteConexion;
        public SqlLiteCrud()
        {
            sqlLiteConexion = new SqlLiteConexion();
            sqlLiteConexion.GetConnectionAsync().CreateTableAsync<ProductosMesa>();
        }

        public async void ActualizarProductos(ProductosMesa producto)
        {
            await sqlLiteConexion.GetConnectionAsync().UpdateAsync(producto);
        }

        public async Task<int> BorrarProductos(ProductosMesa producto)
        {
            var data = await sqlLiteConexion.GetConnectionAsync().DeleteAsync(producto);
            return data;
        }

        public void BorrarTabla()
        {
            sqlLiteConexion.GetConnectionAsync().DeleteAllAsync<ProductosMesa>();
        }

        public async Task<List<ProductosMesa>> GetProductos()
        {
            return sqlLiteConexion
                        .Conn()
                        .Table<ProductosMesa>().ToList();
        }

        public async void InsertarProductos(ProductosMesa producto)
        {
            try
            {

                await sqlLiteConexion.GetConnectionAsync().InsertAsync(producto);
                await sqlLiteConexion.GetConnectionAsync().CloseAsync();
                await Xamarin.Forms.Application.Current.MainPage.DisplayAlert("Agregar a cocina", "Guardado", "ok");
            }
            catch (SQLiteException)
            {
            }

        }

        public async Task<List<ProductosMesa>> MaxRegistro()
        {

            return sqlLiteConexion.Conn().Table<ProductosMesa>().ToList();
        }
    }
}


```

Para hacer las acciones del Crud lo recomendado es usar el MVVM.
Primero llamamos de forma global la interface ISqlLiteCrud.

```c#
private ISqlLiteCrud sqlLiteCrud= DependencyService.Get<ISqlLiteCrud>();
```
Ojo: Debemos de agregar la Interface en app.cs

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p0cny26njb43ako5juxt.png)

Usando el metodo para guardar
```c#
public void guardar(){
  ProductosMesa = new ProductosMesa()
            {
                IdRegistro = 1,
                IdProducto = 1,
                Cantidad = 12,
                PrecioDado =122,
                Llevar = true,
                NotasAdicionales="notas",
                Desc1="qweqwe",
                Desc2="asdasd",
                IdMesa = 1
               
            };
            
            if (ProductosMesa != null)
            {
                sqlLiteCrud.InsertarProductos(ProductosMesa);
                              
            
            }
}
```
Obtener la cantidad de registros de la tabla.
Para hacer esto llamaremos el método MaxRegistro   de la clase SqlLiteCrud que obtiene la lista de registros de la tabla.

```
 var data=sqlLiteCrud.MaxRegistro().Result;//obtenemos registro
 int Id = data.Count();//contamos cantidad de registros
```

> Esta es una manera un poco compleja de crear conexión a SqLite en Xamarin forms.