public interface IMenuRepository : IRepository<Menu>
    {
        IEnumerable<Menu> MenuLists();
    }
 
public class MenuRepository : Repository<Menu>, IMenuRepository
    {
        private readonly TestCRUDSignalREntitie _context;
        public MenuRepository(TestCRUDSignalREntitie context) : base(context)
        {
            _context = context;
        }
        public TestCRUDSignalREntitie DatabaseContext => Context as TestCRUDSignalREntitie;
 
 
 
 
        public IEnumerable<Menu> MenuLists()
        {
            ///!!!!!!!!!!!!!!!!!!????????????
             //return _context.Menus
        }
 
 
    }

public interface IUnitOfWork : IDisposable
    {
        IMenuRepository MenuRepository { get; }
 
 
        int Complete();
    }
 
    public class UnitOfWork : IUnitOfWork
    {
        private readonly TestCRUDSignalREntitie _context;
        public IMenuRepository MenuRepository { get; private set; }
        public UnitOfWork(TestCRUDSignalREntitie context)
        {
            _context = context;
            MenuRepository = new MenuRepository(_context);
        }
        public int Complete()
        {
            return _context.SaveChanges();
        }
 
 
        public void Dispose()
        {
            _context.Dispose();
        }
    }
 
namespace WindowsFormsApp1
{
    public interface IRepository<TEntity> where TEntity : class
    {
 
 
        TEntity Get(object id);
 
 
 
 
        IEnumerable<TEntity> GetAll();
 
 
 
 
        TEntity GetRow();
 
 
 
 
        TEntity GetAllEntity();
 
 
 
 
        IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> perdicate);
 
 
 
 
 
 
        TEntity FindSelect(Expression<Func<TEntity, bool>> perdicate);
 
 
        bool FindRow(Expression<Func<TEntity, bool>> perdicate);
 
 
 
 
        IEnumerable<TEntity> FindRawSql(string query, params object[] parameters);
 
 
 
 
        void Add(TEntity entity);
 
 
 
 
        void AddRange(IEnumerable<TEntity> entities);
 
 
 
 
        void Remove(TEntity entity);
 
 
 
 
        void RemoveRange(IEnumerable<TEntity> entities);
 
 
        void Update(TEntity entity);
 
 
    }
}
 
    public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        protected readonly DbContext Context;
 
 
        public Repository(DbContext context)
        {
            Context = context;
        }
 
 
        public virtual TEntity Get(object id)
        {
            return Context.Set<TEntity>().Find(id);
        }
 
 
        public virtual IEnumerable<TEntity> GetAll()
        {
            return Context.Set<TEntity>().ToList();
        }
 
 
        public virtual TEntity GetRow()
        {
            return Context.Set<TEntity>().FirstOrDefault();
        }
 
 
        public virtual TEntity GetAllEntity()
        {
            return Context.Set<TEntity>().FirstOrDefault();
        }
 
 
        public virtual IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
        {
            return Context.Set<TEntity>().Where(predicate);
        }
 
 
 
 
        public virtual TEntity FindSelect(Expression<Func<TEntity, bool>> predicate)
        {
            return Context.Set<TEntity>().Where(predicate).FirstOrDef  ault();
        }
 
 
        public virtual bool FindRow(Expression<Func<TEntity, bool>> predicate)
        {
            var check = Context.Set<TEntity>().Where(predicate).SingleOrDe  fault();
            return check != null;
        }
 
 
        public IEnumerable<TEntity> FindRawSql(string query, params object[] parameters)
        {
            return Context.Set<TEntity>().SqlQuery(query, parameters).ToList();
        }
 
 
        public virtual void Add(TEntity entity)
        {
            Context.Set<TEntity>().Add(entity);
        }
 
 
        public virtual void AddRange(IEnumerable<TEntity> entities)
        {
            Context.Set<TEntity>().AddRange(entities);
        }
 
 
        public virtual void Remove(TEntity entity)
        {
            Context.Set<TEntity>().Remove(entity);
        }
 
 
        public virtual void RemoveRange(IEnumerable<TEntity> entities)
        {
            Context.Set<TEntity>().RemoveRange(entities);
        }
 
 
        public virtual void Update(TEntity entity)
        {
            Context.Set<TEntity>().Attach(entity);
            Context.Entry(entity).State = EntityState.Modified;
        }
 
 
 
 
    }