Task Started in Controller Action Running Synchronously

Question

The Problem

I'm working on a web portal that loads a WebUser object when a user logs in via EF. WebUser has a non-trivial object graph and loading it via EF can take 2-3 seconds (optimizing that load time is a separate issue).

In order to improve perceived performance, I want to load the WebUser as soon as the user logs on to the system, on a separate thread. However, my current attempt runs synchronously for reasons that I do not understand.

The Code

static private ConcurrentDictionary<string, WebUser> userCache = 
        new ConcurrentDictionary<string, WebUser>();

static public void CacheProfile(string userName)
{
    if (!userCache.ContainsKey(userName)) 
    {
        logger.Debug("In CacheProfile() and there is no profile in cache");
        Task bg = GetProfileAsync(userName);
        logger.Debug("Done CacheProfile()");
    }
}

static public async Task<WebUser> GetProfileAsync(string userName)
{
    logger.Debug("GetProfileAsync for " + userName);

    await currentlyLoading.NotInSet(userName); // See NOTE 1 below

    if (userCache.ContainsKey(userName))
    {
        logger.Debug("GetProfileAsync from memory cache for " + userName);
        return userCache[userName];
    }
    else
    {
        currentlyLoading.Add(userName);

        logger.Debug("GetProfileAsync from DB for " + userName);

        using (MembershipContext ctx = new MembershipContext())
        {
            ctx.Configuration.LazyLoadingEnabled = false;
            ctx.Configuration.ProxyCreationEnabled = false;
            ctx.Configuration.AutoDetectChangesEnabled = false;

            var wu = GetProfileForUpdate_ExpensiveMethod(ctx, userName);
            userCache[userName] = wu;
            currentlyLoading.Remove(userName);

            return wu;
        }
    }

}

NOTE 1: currentlyLoading is a static instance of ConcurrentWaitUntil<T>. The intent is to cause a second request for a given user's profile to block if the first request is still loading from the database. Perhaps there is a better way to accomplish this? Code:

public class ConcurrentWaitUntil<T>
{
    private HashSet<T> set = new HashSet<T>();
    private Dictionary<T, TaskCompletionSource<bool>> completions = new Dictionary<T, TaskCompletionSource<bool>>();

    private object locker = new object();

    public async Task NotInSet(T item)
    {
        TaskCompletionSource<bool> completion;

        lock (locker)
        {
            if (!set.Contains(item)) return;

            completion = new TaskCompletionSource<bool>();
            completions.Add(item, completion);
        }

        await completion.Task;
    }

    public void Add(T item)
    {
        lock (locker)
        {
            set.Add(item);
        }
    }

    public void Remove(T item)
    {
        lock (locker)
        {
            set.Remove(item);

            TaskCompletionSource<bool> completion;
            bool found = completions.TryGetValue(item, out completion);

            if (found)
            {
                completions.Remove(item);

                completion.SetResult(true); // This will allow NotInSet() to complete
            }
        }
    }
}

The Question

Why does CacheProfile() seem to wait until GetProfileAsync() has completed?

SIDE NOTE: I know that the ConcurrentDictionary does not scale well and that I should use ASP.Net's cache.

Answer 1

Why does CacheProfile() seem to wait until GetProfileAsync() has completed?

It sounds like your GetProfileAsync is first doing synchronous database calls and then performing some asynchronous operation.

Since you're using EF, you could fix this by upgrading to EF6 and using asynchronous queries.

Alternatively, Task.Run would make it work, but that is not recommended on the server side because it hurts your scalability.

On a side note, I prefer to structure in-memory asynchronous caches so that they cache tasks instead of results, so something like this:

static private ConcurrentDictionary<string, Task<WebUser>> userCache = new ConcurrentDictionary<string, Task<WebUser>>();

static public Task<WebUser> GetProfileAsync(string userName)
{
  return userCache.GetOrAdd(userName, _ =>
  {
    logger.Debug("In GetProfileAsync() and there is no profile in cache");
    return LoadProfileAsync(userName);
  });
}

static private async Task<WebUser> LoadProfileAsync(string userName)
{
  // Load it from DB using EF6 async queries.
  // Don't block other callers.

  logger.Debug("Loading from DB complete");
}

Then on the initial login, you can just call GetProfileAsync and ignore the result.

Answer 2

Your CacheProfile method needs to be async as well. Otherwise, it will not end until it gets result from GetProfileAsync

If you just want fire and forget use this:

static void ReadAndCache()
{
    // retrieve and place in cache
}

static public void GetProfileAsync(string userName)
{
    Task.Run(() => ReadAndCache());
}

Answer 3

I think using await will get you desired behavior.Please look at the following

static public void CacheProfile(string userName)
{
    if (!userCache.ContainsKey(userName)) 
    {
        logger.Debug("In CacheProfile() and there is no profile in cache");
        Task bg = GetProfileAsync(userName); 
        logger.Debug("Done CacheProfile()");
    }
}

static public async Task<WebUser> GetProfileAsync(string userName)
{
    //load you data here.
    // will create a new thread and start task and return to the calling method.
    return await Task.Run(() => { 
                //your code which fetches data goes here
                //which returns a "WebUser" object
            });
    logger.Debug("Loading from DB complete");
}