OHV/Dev/OHV/OHV.SqliteDAL/DAL/AbstractDAL.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Core.Objects;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Validation;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using GSG.NET.Logging;
using GSG.NET.Utils;

namespace OHV.SqliteDAL.DAL
{
    public class GenericDAL<T> where T : class
    {
        public delegate void DlgChangedProperty();
        public event DlgChangedProperty ChangedProperty;

        protected virtual void OnChangedProperty()
        {
            ChangedProperty?.BeginInvoke( null, null );
        }

        public List<T> All
        {
            get
            {
                List<T> ll = new List<T>();
                using ( var db = new OHVDbContext( "OHVDb" ) )
                {
                    ll = db.Set<T>().ToList();
                }
                return ll;
            }
        }

        public int Count
        {
            get
            {
                using ( var db = new OHVDbContext( "OHVDb" ) )
                {
                    return db.Set<T>().Count();
                }
            }

        }

        public T GetK( object key )
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                return db.Set<T>().Find( key );
            }
        }

        public List<T> ListN( Expression<Func<T, bool>> where )
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                return db.Set<T>().Where( where ).ToList();
            }
        }

        public virtual bool HasK( object key )
        {
            return GetK( key ) == null ? false : true;
        }

        public virtual bool HasN( Expression<Func<T, bool>> where )
        {
            List<T> ll = new List<T>();
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                ll = db.Set<T>().Where( where ).ToList();
            }
            return ll.Count > 0;
        }

        public void Add( T entity )
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                db.Set<T>().Add( entity );
                db.SaveChanges();
            }
            OnChangedProperty();
        }

        public void Delete( T entity )
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                db.Entry( entity ).State = EntityState.Deleted;
                //db.Set<T>().Remove(entity);
                db.SaveChanges();
            }
            OnChangedProperty();
        }

        public virtual void Update( T entity )
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                db.Entry( entity ).State = EntityState.Modified;
                db.SaveChanges();
            }
            OnChangedProperty();
        }

        public void Clean()
        {
            using ( var db = new OHVDbContext( "OHVDb" ) )
            {
                db.Set<T>().RemoveRange( db.Set<T>() );
                db.SaveChanges();
            }
            OnChangedProperty();
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////
    public interface IGenericRepository<T> where T : class
    {
        event Action OnChangeTable;
        int Count { get; }
        IEnumerable<T> GetAll();
        IEnumerable<T> Get( Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeProperties = "" );
        T GetById( object id );
        void Insert( T obj );
        void Update( T obj );
        void Delete( object id );
        void Delete( Expression<Func<T, bool>> filter = null );
        void Clean();
        void Save();
        void Dispose();
    }

    class GenericRepository<T> : IGenericRepository<T> where T : class
    {
        protected Logger logger = Logger.GetLogger();

        private OHVDbContext _context = null;
        private DbSet<T> table = null;

        public event Action OnChangeTable;

        object lockObj = new object();

        public int Count { get => GetAll().Count(); }

        public GenericRepository()
        {
            this._context = new OHVDbContext( "OHVDb" );
            this.table = this._context.Set<T>();
        }

        public GenericRepository( OHVDbContext dbContext )
        {
            this._context = dbContext;
            this.table = _context.Set<T>();
        }

        public void Dispose()
        {
            this._context.Dispose();
        }

        public IEnumerable<T> GetAll()
        {
            //lock ( lockObj )
                return table.ToList();
        }

        public virtual IEnumerable<T> Get( Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeProperties = "" )
        {
            lock ( lockObj )
            {
                IQueryable<T> query = this.table;

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

                if ( includeProperties != null )
                {
                    foreach ( var includeProperty in includeProperties.Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ) )
                        query = query.Include( includeProperty );
                }

                if ( orderBy != null )
                    return orderBy( query ).ToList();
                else
                    return query.ToList();
            }
        }

        public T GetById( object id )
        {
            lock ( lockObj )
                return table.Find( id );
        }

        public void Insert( T obj )
        {
            lock ( lockObj )
            {
                table.Add( obj );
                this.Save();
            }
        }

        public void Update( T obj )
        {
            if ( obj == null )
            {
                logger.E( $"[DataBase] - Update obj is Null {this.table.GetType().Name}" );
                return;
            }

            lock ( lockObj )
            {
                table.Attach( obj );
                _context.Entry( obj ).State = EntityState.Modified;
                this.Save();
            }
        }

        public void Delete( object id )
        {
            T existing = table.Find( id );
            if ( existing == null )
                return;

            lock ( lockObj )
            {
                if ( _context.Entry( existing ).State == EntityState.Detached )
                {
                    table.Attach( existing );
                }

                table.Remove( existing );
                this.Save();
            }
        }

        public void Delete( Expression<Func<T, bool>> filter )
        {
            lock ( lockObj )
            {
                var delList = this.table.Where( filter ).ToList();
                if ( delList.Count > 0 )
                {
                    this.table.RemoveRange( delList );
                    Save();
                }
            }
        }

        public void Clean()
        {
            lock ( lockObj )
            {
                var ll = this.GetAll();
                if (ll.Count() <= 0)
                    return;

                table.RemoveRange( ll );
                this.Save();
            }
        }

        public void Save()
        {
            try
            {
                _context.SaveChanges();
            }
            catch ( DbEntityValidationException dbEx )
            {
                foreach ( var validationErrors in dbEx.EntityValidationErrors )
                {
                    foreach ( var validationError in validationErrors.ValidationErrors )
                    {
                        logger.E( "Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage );
                    }
                }

                return;
            }
            //catch ( DbUpdateConcurrencyException ex )
            //{
            //    ex.Entries.Single().Reload();
            //    logger.E( $"[DataBase] - DbUpdateConcurrencyException {this.table.GetType().Name}" );
            //    return;
            //}
            this.OnChangeTable?.Invoke();
            //DelegateUtils.Invoke(OnChangeTable);
        }
    }


    ////////////////////////////////////////////////////////////////////////////////////////
    public interface IGenericRepositoryType1<T> where T : class
    {
        IQueryable<T> GetAll();
        IQueryable<T> FindBy( Expression<Func<T, bool>> predicate );
        void Add( T entity );
        void Delete( T entity );
        void Edit( T entity );
        void Save();
    }

    public abstract class GenericRepository<C, T> : IGenericRepositoryType1<T> where T : class where C : DbContext, new()
    {
        private C _entities = new C();
        public C Context
        {
            get { return _entities; }
            set { _entities = value; }
        }

        public virtual IQueryable<T> GetAll()
        {
            IQueryable<T> query = _entities.Set<T>();
            return query;
        }

        public IQueryable<T> FindBy( System.Linq.Expressions.Expression<Func<T, bool>> predicate )
        {
            IQueryable<T> query = _entities.Set<T>().Where( predicate );
            return query;
        }

        public virtual void Add( T entity )
        {
            _entities.Set<T>().Add( entity );
        }

        public virtual void Delete( T entity )
        {
            _entities.Set<T>().Remove( entity );
        }

        public virtual void Edit( T entity )
        {
            _entities.Entry( entity ).State = EntityState.Modified;
        }

        public virtual void Save()
        {
            _entities.SaveChanges();
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////
    public interface IRepository<T> where T : class
    {
        IEnumerable<T> GetAll();
        T GetById( object Id );
        T Insert( T obj );
        void Delete( object Id );
        T Update( T obj );
        void Save();
    }

    public class Repository<T> : IRepository<T> where T : class
    {
        private OHVDbContext context;
        private DbSet<T> dbSet;
        public Repository()
        {
            context = new OHVDbContext( "OHVDb" );
            dbSet = context.Set<T>();
        }
        public IEnumerable<T> GetAll()
        {
            return dbSet.ToList();
        }
        public T GetById( object id )
        {
            return dbSet.Find( id );
        }
        public T Insert( T obj )
        {
            dbSet.Add( obj );
            Save();
            return obj;
        }

        public void Delete( object id )
        {
            T entityToDelete = dbSet.Find( id );
            Delete( entityToDelete );
        }

        public void Delete( T entityToDelete )
        {
            if ( context.Entry( entityToDelete ).State == EntityState.Detached )
            {
                dbSet.Attach( entityToDelete );
            }

            dbSet.Remove( entityToDelete );
        }

        public T Update( T obj )
        {
            dbSet.Attach( obj );
            context.Entry( obj ).State = EntityState.Modified;
            Save();
            return obj;
        }

        public void Save()
        {
            try
            {
                context.SaveChanges();
            }
            catch ( DbEntityValidationException dbEx )
            {
                foreach ( var validationErrors in dbEx.EntityValidationErrors )
                {
                    foreach ( var validationError in validationErrors.ValidationErrors )
                    {
                        System.Console.WriteLine( "Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage );
                    }
                }
            }
        }

        protected virtual void Dispose( bool disposing )
        {
            if ( disposing )
            {
                if ( context != null )
                {
                    context.Dispose();
                    context = null;
                }
            }
        }
    }

}