如何确保WCF服务不会与数据库并行通信

Question

I have a WCF service, which should return objects from database, but each entity should be returned only once. I would like to avoid scenario, where many clients are using service, and they can get same Request entity.

public Request GetChangeRequest()
{
    using (var context = new Data.Core.Context())
    {
        var request = context.Requests
            .Where(r => r.IsAvaible)
            .FirstOrDefault();

        if (request != null)
        {
            request.IsAvaible = false;
            context.SaveChanges();
        }       
        return request;
    }
}

I am really wondering if there is a reason to give additional security like locking database. To do this I have managed something like this:

public Request GetChangeRequest()
{
    using (var context = new Data.Core.Context())
    {
        context.OnLock<Request>(context.GetTableName<Request>(), () =>
        {
            var request = context.Requests
                .Where(r => r.IsAvaible)
                .FirstOrDefault();

            if (request != null)
            {
                request.IsAvaible = false;
                context.SaveChanges();
            }       
            return request; 
        });
    }
}

public static class DBContextExtensions
{
    public static string GetTableName<T>(this DbContext context) where T : class
    {
        var type = typeof(T);
        var entityName = (context as System.Data.Entity.Infrastructure.IObjectContextAdapter).ObjectContext.CreateObjectSet<T>().EntitySet.Name;
        var tableAttribute = type.GetCustomAttributes(false).OfType<System.ComponentModel.DataAnnotations.Schema.TableAttribute>().FirstOrDefault();

        return tableAttribute == null ? entityName : tableAttribute.Name;
    }

    public static T OnLock<T>(this DbContext context, string tableName, Func<T> action)
    {
        T res;
        using (DbContextTransaction scope = context.Database.BeginTransaction())
        {
            context.Database.ExecuteSqlCommand($"SELECT TOP 1 Id FROM {tableName} WITH (TABLOCKX, HOLDLOCK)");
            res = action.Invoke();
            scope.Commit();
        }
        return res;
    }
}

I couldn't reproduce scenerio, when two request entity are returned to two different clients. Does that mean, that WCF service performs requests sequentially?

Answer 1

Instead of implementing a locking mechanism by yourself, one possible solution would be running the service as a singleton and not allowing parallel requests.

You can achieve this by setting your WCF Service properties InstanceContextMode and ConcurrencyMode to Single .

For more information about Sessions, Instancing, and Concurrency see here .

Answer 2

You should be able to use concurrency checking to make sure that only one entity is returned, without blocking the WCF to one query at a time.

You need a special field in you entity class with an attribute [Timestamp] and then catch the DbUpdateConcurrencyException when saving, which will let you know that someone else has already returned that record, so you should get another one.

public class Request
{
    ...
    [Timestamp]
    public byte[] RowVersion { get; set; }
}

public Request GetChangeRequest()
{
    using (var context = new Data.Core.Context())
    {
        while (true)
        {
            try
            {
                var request = context.Requests
                    .Where(r => r.IsAvaible)
                    .FirstOrDefault();

                request.IsAvaible = false;
                context.SaveChanges();
                return request;
            }
            catch (DbUpdateConcurrencyException)
            {
            }
        }
    }
}

See here for more details