public interface IStorable<TKey> {
    public TKey id { get; }
}

public class BaseFilter {
    public int? Skip;
    public int? Take;
}

public interface IRepository<TEntity, TKey, TFilter>
            where TEntity: IStorable<TKey>
            where TKey: struct
            where TFilter: BaseFilter
{
    IQueriable<TEntity> GetById(TKey id);
    IQueriable<TEntity> GetMany(TFilter filter);
    void Save(TEntity obj);
    void Delete(TKey id);
    void Commit();
}

public abstract class BaseRepository<TEntity, TKey, TFilter, TDbContext>:
                            IRepository<TEntity, TKey, TFilter>
            where TDbContext: DbContext
            where TEntity: IStorable<TKey>
            where TKey: struct
            where TFilter: BaseFilter
{
    protected TDbContext _context;

    public BaseRepository(TDbContext context) {
        _context = context;
    }

    IQueriable<TEntity> GetById(TKey id) {
        return _context.Set<TEntity>().Where(x => x.Id == id);
    }

    IQueriable<TEntity> GetMany(TFilter filter) {
        var query = _context.Set<TEntity>();

        query = ApplyFilter(query, filter);

        return query.Skip(filter?.Skip ?? 0)
                    .Take(filter?.Take ?? 20);
    }

    void Save(TEntity obj) {
        if (obj.Id == default) {
            _context.Set<TEntity>().Add(obj);
        } else {
            _context.Save(obj);
        }
    }

    void Delete(TKey id) {
        var found = GetById(id).FirstOrDefault();
        if (found == null) ...
        _context.Remove(obj);
    }

    void Commit() => _context.SaveChanges();


    public virtual IQueriable<TEntity> ApplyFilter(IQueriable<TEntity> query, TFilter filter) => query;
}








public class Post: IStorable<int>
{
    public int Id { get; set; }
    public bool IsDraft { get; set; }

    public string Title { get; set; }
    public string Content { get; set; }
}

public class PostFilter: BaseFilter {
    public bool PublishedOnly { get; set; }
}

public interface IPostRepository: IRepository<Post, int, PostFilter>
{
}

public class PostRepository: BaseRepository<Post, int, PostFilter, MyDbContext>
{
    public PostRepository(MyDbContext context): base(context) {}

    public override IQueriable<TEntity> ApplyFilter(IQueriable<Post> query,
                                                    PostFilter filter)
    {
        var baseQuery = base.ApplyFilter(query);

        if (filter != null && filter.PublishedOnly) {
            return baseQuery.Where(x => !x.IsDraft);
        }

        return baseQuery;
    }
}