Generisches Repository für SQLite-Net Xamarin-Projekt

Frage ich mich, ob es einen Weg gibt, zu schreiben, ein generisches repository für meine Xamarin Projekt-versus schreiben, ein anderes Repository für jede Entität in meinem Objekt. Die Xamarin Tasky Pro Beispiel haben ein Repository für die Aufgabe ein entity-denn das ist die einzige Entität ist, die es hat.

In meinem eigenen Projekt habe ich mehr als eine Entität, so meine Frage ist wie kann ich das machen
die folgenden Customer-Repository zu generisch, so dass die ProductManager, EmployeeManager, etc. verwenden können. Wenn Sie wissen, ein Beispiel oder einen blog-post, bitte zeigen Sie mir die richtige Richtung

namespace App.DataLayer
{
    public class CustomerRepository
    {
        private ProntoDatabase _db = null;
        protected static string DbLocation;
        protected static CustomerRepository Me;

        static CustomerRepository()
        {
            Me = new CustomerRepository();
        }

        protected CustomerRepository()
        {
            //set the db location;
            DbLocation = DatabaseFilePath;

            //instantiate the database
            _db = new ProntoDatabase(DbLocation);
        }


        public static string DatabaseFilePath
        {
            get
            {
                const string sqliteFilename = "CustomerDB.db3";
                var libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
                var path = Path.Combine(libraryPath, sqliteFilename);
                return path;
            }
        }


        //CRUD (Create, Read, Update and Delete) methods

        public static Customer GetCustomer(int id)
        {
            return Me._db.GetItem<Customer>(id);
        }

        public static IEnumerable<Customer> GetCustomers()
        {
            return Me._db.GetItems<Customer>();
        }

        public static int SaveCustomer(Customer item)
        {
            return Me._db.SaveItem(item);
        }

        public static int DeleteCustomer(int id)
        {
            return Me._db.DeleteItem<Customer>(id);
        }
    }

Sie haben nun passieren in einer Implementierung ISQlitePlatform in der SQLiteConnectionWithLock und SQLiteConnection Konstruktoren. Die richtige Plattform-Implementierung wird dem Projekt automatisch Hinzugefügt.

InformationsquelleAutor Val Okafor | 2015-03-14

c#repository-pattern sqlite-net xamarin

Dies ist eine alte Frage, aber hier ist meine Umsetzung.

Im mit asynchronen verbindungen, wie Sie bieten eine bessere performance in mobile-Projekten. Die nuggets habe ich installiert sind Sqlite.Net-PCL/SQLite.Net.Async-PCL auf das Core-Projekt und die entsprechenden nuget in das Android-Projekt.

Mein Repository sieht wie folgt aus:

using System;
using System.Collections.Generic;
using Core.Models;
using SQLite.Net;
using System.Linq;
using SQLite.Net.Async;
using System.Threading.Tasks;
using System.Linq.Expressions;

namespace Core.Managers
{
    public interface IRepository<T> where T : class, new()
    {
        Task<List<T>> Get();
        Task<T> Get(int id);
        Task<List<T>> Get<TValue>(Expression<Func<T, bool>> predicate = null, Expression<Func<T, TValue>> orderBy = null);
        Task<T> Get(Expression<Func<T, bool>> predicate);
        AsyncTableQuery<T> AsQueryable();
        Task<int> Insert(T entity);
        Task<int> Update(T entity);
        Task<int> Delete(T entity);
    }

    public class Repository<T> : IRepository<T> where T : class, new()
    {
        private SQLiteAsyncConnection db;

        public Repository(SQLiteAsyncConnection db)
        {
            this.db = db;
        }

        public AsyncTableQuery<T> AsQueryable() => 
            db.Table<T>();

        public async Task<List<T>> Get() => 
            await db.Table<T>().ToListAsync();

        public async Task<List<T>> Get<TValue>(Expression<Func<T, bool>> predicate = null, Expression<Func<T, TValue>> orderBy = null)
        {
            var query = db.Table<T>();

            if (predicate != null)
                query = query.Where(predicate);

            if (orderBy != null)
                query = query.OrderBy<TValue>(orderBy);

            return await query.ToListAsync();
        }

        public async Task<T> Get(int id) => 
             await db.FindAsync<T>(id);

        public async Task<T> Get(Expression<Func<T, bool>> predicate) =>
            await db.FindAsync<T>(predicate);

        public async Task<int> Insert(T entity) => 
             await db.InsertAsync(entity);

        public async Task<int> Update(T entity) =>
             await db.UpdateAsync(entity);

        public async Task<int> Delete(T entity) =>
             await db.DeleteAsync(entity);
    }
}

Einige Beispiele auf, wie es zu benutzen:

var connection = new SQLiteAsyncConnection(() => sqlite.GetConnectionWithLock());
await connection.CreateTablesAsync<Ingredient, Stock>();

IRepository<Stock> stockRepo = new Repository<Stock>(connection);
IRepository<Ingredient> ingredientRepo = new Repository<Ingredient>(connection);

var stock1 = new Stock { 
    IngredientId = 1,
    DaysToExpire = 3,
    EntryDate = DateTime.Now,
    Location = StockLocations.Fridge,
    MeasureUnit = MeasureUnits.Liter,
    Price = 5.50m,
    ProductName = "Leche Auchan",
    Quantity = 3,
    Picture = "test.jpg",
    Family = IngredientFamilies.Dairy
};

var stockId = await stockRepo.Insert(stock1);

var all = await stockRepo.Get();
var single = await stockRepo.Get(72);
var search = await stockRepo.Get(x => x.ProductName.StartsWith("something"));
var orderedSearch = await stockRepo.Get(predicate: x => x.DaysToExpire < 4, orderBy: x => x.EntryDate);

Wenn das Repository nicht erfüllt Ihre Abfrage benötigt, können Sie AsQueryable():

public async Task<List<Stock>> Search(string searchQuery, StockLocations location, IngredientFamilies family)
{
    var query = stockRepo.AsQueryable();

    if (!string.IsNullOrEmpty(searchQuery))
    {
        query = query.Where(x => x.ProductName.Contains(searchQuery) || x.Barcode.StartsWith(searchQuery));
    }
    if (location != StockLocations.All)
    {
        query = query.Where(x => x.Location == location);
    }
    if (family != IngredientFamilies.All)
    {
        query = query.Where(x => x.Family == family);
    }

    return await query.OrderBy(x => x.ExpirationDays).ToListAsync();
}

Wow, Super. Das ist genau das, was ich Suche. Ich werde es zu benutzen und sehen, ob ich es verwenden können, um Ersatz für meine 7 verschiedenen repositories
Der Besitzer hat nicht börsennotierte Sqlite.Net.Platform.XamarinAndroid Paket. Dies könnte bedeuten, dass das Paket veraltet ist oder nicht mehr verwendet werden. LINK
Wie hat diese Arbeit ohne die "public class Repository<T> : IRepository<T> where T : class, new()"
Konnten Sie eine Lösung finden? Mein compiler beschwert sich abuout "public class Repository<T> : IRepository<T> where T : new()". Die Fehlermeldung ist :"Der Typ 'T' muss ein Referenztyp sein, um es zu verwenden als parameter " T "in der generischen Typ oder Methode" IRepository<T>'"
Fügen Sie "Klasse" weiter zu der Schnittstelle, wo . einfach Klasse "public class Repository<T> : IRepository<T> where T : class, new()"

InformationsquelleAutor xleon

Meine Implementierung mit Hilfe der unity IOC ist unten gegeben, Mein Projekt beinhaltet die PCL -, Xamarin Android & Xamarin iOS-Projekte

Definieren eine Basis-Modell mit den primär-Schlüssel

public class BaseModel
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }
}

Definieren Sie eine generische base-repository wie unten gezeigt

public interface IBaseRepository<T> : IDisposable
    where T :BaseModel, new()
    {
        List<T> GetItems();

        T GetItem(int id);

        int GetItemsCount();

        int SaveItem(T item);

        int SaveAllItem(IEnumerable<T> items);
    }


public class BaseRepository<T> : BaseRepository<T> where T : BaseModel, new()
    {
        private static readonly object locker = new object();
        protected SQLiteConnection DatabaseConnection;
        public BaseRepository(string dbPath)
        {
            DatabaseConnection = new SQLiteConnection(dbPath);
            DatabaseConnection.CreateTable<T>();
        }

        public List<T> GetItems()
        {
            lock (locker)
            {
                return DatabaseConnection.Table<T>().ToList();
            }
        }

        public int GetItemsCount()
        {
            lock (locker)
            {
                return DatabaseConnection.Table<T>().Count();
            }
        }

        public T GetItem(int id)
        {
            lock (locker)
            {
                return DatabaseConnection.Table<T>().Where(i => i.Id == id).FirstOrDefault();
            }
        }

        public int SaveItem(T item)
        {
            lock (locker)
            {
                if (item.Id != 0)
                {
                    return DatabaseConnection.Update(item);
                }
                else
                {
                    return DatabaseConnection.Insert(item);
                }
            }
        }


    }

Definieren zwei Beispiel-Klassen, die geerbt werden von den BaseModel

public class Entity1 : BaseModel
    {
        public int ItemName
        {
            get;
            set;
        }
    }


public class Entity2 : BaseModel
{
    public int Description
    {
        get;
        set;
    }
}


public static UnityContainer Container { get; private set; }

    public static void InitializeUnityContainer()
    {
        if (Container == null)
            Container = new UnityContainer();
    }

Registrieren

Container.RegisterInstance<IBaseRepository<Entity1>>(new BaseRepository<Entity1>(DatabasePath));
    Container.RegisterInstance<IBaseRepository<Entity2>>(new BaseRepository<Entity2>(DatabasePath));

beheben, wie dies

using (var repo1 = App.Container.Resolve<IBaseRepository<Entity2>>())
{

}

InformationsquelleAutor Shyju M

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.