Litedb: Async support

[furesoft]

could you implement async support?

[nguyentuevuong]

First: Update LiteDB project to .NET 4.5.
Second: Add new partial class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace LiteDB
{
 public partial class LiteCollection<T>
    {
        public async Task<int> CountAsync()
        {
            return await Task.Run(() => Count());
        }

        public async Task<int> CountAsync(Query query)
        {
            return await Task.Run(() => Count(query));
        }

        public async Task<int> CountAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.Run(() => Count(predicate));
        }

        public async Task<bool> DropIndexAsync(string field)
        {
            return await Task.Run(() => DropIndex(field));
        }

        public async Task<long> LongCountAsync()
        {
            return await Task.Run(() => LongCount());
        }

        public async Task<long> LongCountAsync(Query query)
        {
            return await Task.Run(() => LongCount(query));
        }

        public async Task<long> LongCountAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.Run(() => LongCount(predicate));
        }


        public async Task<bool> ExistsAsync(Query query)
        {
            return await Task.Run(() => Exists(query));
        }

        public async Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.Run(() => Exists(predicate));
        }

        public async Task<BsonValue> MinAsync(string field)
        {
            return await Task.Run(() => Min(field));
        }

        public async Task<BsonValue> MinAsync()
        {
            return await Task.Run(() => Min());
        }

        public async Task<BsonValue> MinAsync<K>(Expression<Func<T, K>> property)
        {
            return await Task.Run(() => Min<K>(property));
        }

        public async Task<BsonValue> MaxAsync(string field)
        {
            return await Task.Run(() => Max(field));
        }

        public async Task<BsonValue> MaxAsync()
        {
            return await Task.Run(() => Max());
        }

        public async Task<BsonValue> MaxAsync<K>(Expression<Func<T, K>> property)
        {
            return await Task.Run(() => Max<K>(property));
        }

        public async Task<IEnumerable<T>> FindAsync(Query query, int skip = 0, int limit = int.MaxValue)
        {
            return await Task.Run(() => Find(query, skip, limit));
        }

        public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, int skip = 0, int limit = int.MaxValue)
        {
            return await Task.Run(() => Find(predicate, skip, limit));
        }

        public async Task<IEnumerable<T>> FindAllAsync()
        {
            return await Task.Run(() => FindAll());
        }

        public async Task<T> FindByIdAsync(BsonValue id)
        {
            return await Task.Run(() => FindById(id));
        }

        public async Task<T> FindOneAsync(Query query)
        {
            return await Task.Run(() => FindOne(query));
        }

        public async Task<T> FindOneAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.Run(() => FindOne(predicate));
        }

        public async Task<BsonValue> InsertAsync(T document)
        {
            return await Task.Run(() => Insert(document));
        }

        public async Task<int> InsertAsync(IEnumerable<T> docs)
        {
            return await Task.Run(() => Insert(docs));
        }

        public async Task<bool> UpdateAsync(T document)
        {
            return await Task.Run(() => Update(document));
        }

        public async Task<bool> UpdateAsync(BsonValue id, T document)
        {
            return await Task.Run(() => Update(id, document));
        }

        public async Task<int> UpdateAsync(IEnumerable<T> documents)
        {
            return await Task.Run(() => Update(documents));
        }

        public async Task<int> DeleteAsync(Query query)
        {
            return await Task.Run(() => Delete(query));
        }

        public async Task<int> DeleteAsync(Expression<Func<T, bool>> predicate)
        {
            return await Task.Run(() => Delete(predicate));
        }

        public async Task<bool> DeleteAsync(BsonValue id)
        {
            return await Task.Run(() => Delete(id));
        }
    }
}

[nguyentuevuong]

or class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace LiteDB
{
    public partial class LiteCollection<T>
    {
        public Task<int> CountAsync()
        {
            return Task.FromResult(Count());
        }

        public Task<int> CountAsync(Query query)
        {
            return Task.FromResult(Count(query));
        }

        public Task<int> CountAsync(Expression<Func<T, bool>> predicate)
        {
            return Task.FromResult(Count(predicate));
        }

        public Task<bool> DropIndexAsync(string field)
        {
            return Task.FromResult(DropIndex(field));
        }

        public Task<long> LongCountAsync()
        {
            return Task.FromResult(LongCount());
        }

        public Task<long> LongCountAsync(Query query)
        {
            return Task.FromResult(LongCount(query));
        }

        public Task<long> LongCountAsync(Expression<Func<T, bool>> predicate)
        {
            return Task.FromResult(LongCount(predicate));
        }

        public Task<bool> ExistsAsync(Query query)
        {
            return Task.FromResult(Exists(query));
        }

        public Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate)
        {
            return Task.FromResult(Exists(predicate));
        }

        public Task<BsonValue> MinAsync(string field)
        {
            return Task.FromResult(Min(field));
        }

        public Task<BsonValue> MinAsync()
        {
            return Task.FromResult(Min());
        }

        public Task<BsonValue> MinAsync<K>(Expression<Func<T, K>> property)
        {
            return Task.FromResult(Min<K>(property));
        }

        public Task<BsonValue> MaxAsync(string field)
        {
            return Task.FromResult(Max(field));
        }

        public Task<BsonValue> MaxAsync()
        {
            return Task.FromResult(Max());
        }

        public Task<BsonValue> MaxAsync<K>(Expression<Func<T, K>> property)
        {
            return Task.FromResult(Max<K>(property));
        }

        public Task<IEnumerable<T>> FindAsync(Query query, int skip = 0, int limit = int.MaxValue)
        {
            return Task.FromResult(Find(query, skip, limit));
        }

        public Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, int skip = 0, int limit = int.MaxValue)
        {
            return Task.FromResult(Find(predicate, skip, limit));
        }

        public Task<IEnumerable<T>> FindAllAsync()
        {
            return Task.FromResult(FindAll());
        }

        public Task<T> FindByIdAsync(BsonValue id)
        {
            return Task.FromResult(FindById(id));
        }

        public Task<T> FindOneAsync(Query query)
        {
            return Task.FromResult(FindOne(query));
        }

        public Task<T> FindOneAsync(Expression<Func<T, bool>> predicate)
        {
            return Task.FromResult(FindOne(predicate));
        }

        public Task<BsonValue> InsertAsync(T document)
        {
            return Task.FromResult(Insert(document));
        }

        public Task<int> InsertAsync(IEnumerable<T> docs)
        {
            return Task.FromResult(Insert(docs));
        }

        public Task<bool> UpdateAsync(T document)
        {
            return Task.FromResult(Update(document));
        }

        public Task<bool> UpdateAsync(BsonValue id, T document)
        {
            return Task.FromResult(Update(id, document));
        }

        public Task<int> UpdateAsync(IEnumerable<T> documents)
        {
            return Task.FromResult(Update(documents));
        }

        public Task<int> DeleteAsync(Query query)
        {
            return Task.FromResult(Delete(query));
        }

        public Task<int> DeleteAsync(Expression<Func<T, bool>> predicate)
        {
            return Task.FromResult(Delete(predicate));
        }

        public Task<bool> DeleteAsync(BsonValue id)
        {
            return Task.FromResult(Delete(id));
        }
    }
}

[Dessix]

This is probably not what you're looking for. In the former class, you'll make operations that should not be async have huge overhead, and in the latter, you'll make them all blocking operations that _claim_ to be async, but end up adding the additional overhead of bouncing through a task and holding or even boxing the result. Neither of these approaches help you, and the former would best be manually applied where _necessary_.

LiteDB's threading is in progress and still somewhat iffy, with issues such as #73 and #116 still existing to make even standard multithreading a scary or otherwise lock-heavy operation. Adding async on top of a system that has these issues is begging for trouble when the current API is still in progress, _especially_ when noting, as in the previous paragraph, that it will give you no benefit.

[artizzan]

Actually, the former class will use thread pool and completely break thread safety. Don't use it! LiteDatabase is not thread safe.

Building a correct and efficient async adapter to this DB would be difficult. It will be easier to offload entire data operation to a worker task, including the act of initializing a LiteDB and disposing of it, so that everything is scoped to the worker thread. Then you can await the whole task and even use explicit transactions.

An example:

[Test]
public async void Run()
{
    TankModel result = await Task.Run(() =>
    {
        using (var db = new LiteDatabase(DbFullPath))
        {
            return db.GetCollection<TankModel>("TankModels")
                       .Find(model => model.Name == "panzer").SingleOrDefault();
        } 
    });

    ShowOnHypotheticalGui(result);
}