gravity00/simplepersistence

Simple Persistence is a set of libraries that help developers to create consistent database models and data access code across multiple applications in a simple way.

simplepersistence's Issues

EFAsyncQueryable.AnyAsync(predicate, ct) not filtering

Both EFAsyncQueryable.AnyAsync(predicate, ct) and EFAsyncQueryable.AnyAsync(predicate) are not filtering the results.

Wrong result:

await _uow.PrepareAsyncQueryable(_uow.Orders.Query()).AnyAsync(e => e.Id == "9900115121623520000000389", ct) // true

SELECT 
    CASE WHEN ( EXISTS (SELECT 
        1 AS [C1]
        FROM [Orders] AS [Extent1]
    )) THEN cast(1 as bit) ELSE cast(0 as bit) END AS [C1]
FROM  ( SELECT 1 AS X ) AS [SingleRowTable1]

Correct result:

await _uow.PrepareAsyncQueryable(_uow.GreenLane.Orders.Query().Where(e => e.Id == "9900115121623520000000389")).AnyAsync(ct) // false

exec sp_executesql N'SELECT 
    CASE WHEN ( EXISTS (SELECT 
        1 AS [C1]
        FROM [Orders] AS [Extent1]
        WHERE [Extent1].[Id] = @p__linq__0
    )) THEN cast(1 as bit) ELSE cast(0 as bit) END AS [C1]
    FROM  ( SELECT 1 AS X ) AS [SingleRowTable1]',N'@p__linq__0 nvarchar(4000)',@p__linq__0=N'9900115121623520000000389'

Thread dead lock on multiple commits

When using the extension method ExecuteAndCommitAsync<T>(IUnitOfWork, Func<Task<T>>), if the commit is invoked inside the lambda, the method wont return, making a possible dead lock.

Example:

return Created(await _uow.ExecuteAndCommitAsync(async () =>
{
    var userIdentity = User.Identity.Name;

    entity.CreatedBy(userIdentity);
    entity.IndustryAgent = industryAgent;
    entity.RetailAgent = retailAgent;
    entity.Pharmacy = pharmacy;
    entity.Product = product;
    entity.Id = Guid.NewGuid();
    entity = await _uow.Orders.AddAsync(entity, ct);

    await _uow.CommitAsync(ct);

    return entity;
}, ct));    //  won't return, possible a dead lock

UoW.ExecuteAndCommitAsync does not keep culture in MVC applications

The extension method ExecuteAndCommitAsync is not keeping the current culture and UI culture in ASP.NET 4.5+ applications, making it hard to use resource files properly.
Example:

public async Task<IHttpActionResult> Post(Order entity, CancellationToken ct){

    var resourceText01 = Resources.SomeResourceText;

    return await _uow.ExecuteAndCommitAsync(async () => {

        var resourceText02 = Resources.SomeResourceText;

        if(resourceText01 != resourceText02)
            throw new Exception(
                string.Format("The resource text does not match: {0} != {1}", resourceText01, resourceText02));

        await Task.Delay(3000, ct);

        return Created(entity);
    });
}

Missing async IQueryable operations

The IAsyncQueriable interface is missing a lot of async methods. Example: MaxAsync

ExecuteAndCommitAsync extensions throw AggregateException

The extension methods ExecuteAndCommitAsync are throwing AggregateExceptions instead of the expected exception when using async/await. Example:

try
{
    await _uow.ExecuteAndCommitAsync(async () =>
    {
        throw new ConcurrencyException();
    }, ct);
}
catch (ConcurrencyException)
{
    // won't be catched here
}
catch (AggregateException e)
{
    // will be catched here
}

Implementation of IAsyncQueryable<T> for NHibernate

Missing implementation of IAsyncQueryable for the NHibernate framework

Logging support

Logging support to make debugging easier, specially when managing scopes and internal exception

Jetbrain Annotations

Using Jetbrains Annotations (ex: [NotNull], [CanBeNull]) would be a nice addition

UoWExtensions are not generic

The extensions present in the UnitOfWorkExtensions class are not generic. It makes some methods (example: public static Task<T> ExecuteAndCommitAsync<T>(this IUnitOfWork uow, Func<IUnitOfWork, CancellationToken, Task<T>> toExecute)) not very helpful because the lambda must cast the IUnitOfWork object to the expected one.