diff --git a/Source/EntityFramework.Extended/Batch/IBatchRunner.cs b/Source/EntityFramework.Extended/Batch/IBatchRunner.cs
index bb53626..50da907 100644
--- a/Source/EntityFramework.Extended/Batch/IBatchRunner.cs
+++ b/Source/EntityFramework.Extended/Batch/IBatchRunner.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Data.Entity.Core.Objects;
 using System.Linq.Expressions;
+using System.Threading.Tasks;
 using EntityFramework.Mapping;
 
 namespace EntityFramework.Batch
@@ -22,6 +23,17 @@ public interface IBatchRunner
         int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query) 
             where TEntity : class;
 
+        /// <summary>
+        /// Create and runs a batch delete statement asynchronously.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="objectContext">The <see cref="ObjectContext"/> to get connection and metadata information from.</param>
+        /// <param name="entityMap">The <see cref="EntityMap"/> for <typeparamref name="TEntity"/>.</param>
+        /// <param name="query">The query to create the where clause from.</param>
+        /// <returns>The number of rows deleted.</returns>
+        Task<int> DeleteAsync<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query)
+            where TEntity : class;
+
         /// <summary>
         /// Create and runs a batch update statement.
         /// </summary>
@@ -33,5 +45,17 @@ int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuer
         /// <returns>The number of rows updated.</returns>
         int Update<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression) 
             where TEntity : class;
+
+        /// <summary>
+        /// Create and runs a batch update statement asynchronously.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="objectContext">The <see cref="ObjectContext"/> to get connection and metadata information from.</param>
+        /// <param name="entityMap">The <see cref="EntityMap"/> for <typeparamref name="TEntity"/>.</param>
+        /// <param name="query">The query to create the where clause from.</param>
+        /// <param name="updateExpression">The update expression.</param>
+        /// <returns>The number of rows updated.</returns>
+        Task<int> UpdateAsync<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression)
+            where TEntity : class;
     }
 }
diff --git a/Source/EntityFramework.Extended/Batch/SqlServerBatchRunner.cs b/Source/EntityFramework.Extended/Batch/SqlServerBatchRunner.cs
index a8c494a..e01baf8 100644
--- a/Source/EntityFramework.Extended/Batch/SqlServerBatchRunner.cs
+++ b/Source/EntityFramework.Extended/Batch/SqlServerBatchRunner.cs
@@ -8,6 +8,7 @@
 using System.Linq.Expressions;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 using EntityFramework.Extensions;
 using EntityFramework.Mapping;
 using EntityFramework.Reflection;
@@ -29,7 +30,27 @@ public class SqlServerBatchRunner : IBatchRunner
         /// <returns>
         /// The number of rows deleted.
         /// </returns>
-        public int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query)
+        public int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query) where TEntity : class
+        {
+            return InternalDelete(objectContext, entityMap, query, false).Result;
+        }
+
+        /// <summary>
+        /// Create and run a batch delete statement asynchronously.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="objectContext">The <see cref="ObjectContext"/> to get connection and metadata information from.</param>
+        /// <param name="entityMap">The <see cref="EntityMap"/> for <typeparamref name="TEntity"/>.</param>
+        /// <param name="query">The query to create the where clause from.</param>
+        /// <returns>
+        /// The number of rows deleted.
+        /// </returns>
+        public Task<int> DeleteAsync<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query) where TEntity : class
+        {
+            return InternalDelete(objectContext, entityMap, query, true);
+        }
+
+        private async Task<int> InternalDelete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, bool async = false)
             where TEntity : class
         {
             DbConnection deleteConnection = null;
@@ -89,7 +110,9 @@ public int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, Obj
 
                 deleteCommand.CommandText = sqlBuilder.ToString();
 
-                int result = deleteCommand.ExecuteNonQuery();
+                int result = async
+                    ? await deleteCommand.ExecuteNonQueryAsync()
+                    : deleteCommand.ExecuteNonQuery();
 
                 // only commit if created transaction
                 if (ownTransaction)
@@ -121,7 +144,28 @@ public int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, Obj
         /// <returns>
         /// The number of rows updated.
         /// </returns>
-        public int Update<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression)
+        public int Update<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression) where TEntity : class
+        {
+            return InternalUpdate(objectContext, entityMap, query, updateExpression, false).Result;
+        }
+
+        /// <summary>
+        /// Create and run a batch update statement asynchronously.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="objectContext">The <see cref="ObjectContext"/> to get connection and metadata information from.</param>
+        /// <param name="entityMap">The <see cref="EntityMap"/> for <typeparamref name="TEntity"/>.</param>
+        /// <param name="query">The query to create the where clause from.</param>
+        /// <param name="updateExpression">The update expression.</param>
+        /// <returns>
+        /// The number of rows updated.
+        /// </returns>
+        public Task<int> UpdateAsync<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression) where TEntity : class
+        {
+            return InternalUpdate(objectContext, entityMap, query, updateExpression, true);
+        }
+
+        private async Task<int> InternalUpdate<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression, bool async = false)
             where TEntity : class
         {
             DbConnection updateConnection = null;
@@ -297,7 +341,9 @@ public int Update<TEntity>(ObjectContext objectContext, EntityMap entityMap, Obj
 
                 updateCommand.CommandText = sqlBuilder.ToString();
 
-                int result = updateCommand.ExecuteNonQuery();
+                int result = async
+                    ? await updateCommand.ExecuteNonQueryAsync()
+                    : updateCommand.ExecuteNonQuery();
 
                 // only commit if created transaction
                 if (ownTransaction)
diff --git a/Source/EntityFramework.Extended/Caching/CacheManager.cs b/Source/EntityFramework.Extended/Caching/CacheManager.cs
index e155ca9..99e1e55 100644
--- a/Source/EntityFramework.Extended/Caching/CacheManager.cs
+++ b/Source/EntityFramework.Extended/Caching/CacheManager.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace EntityFramework.Caching
 {
@@ -285,6 +286,23 @@ public virtual object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFa
             return item;
         }
 
+        /// <summary>
+        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned asynchronously by <paramref name="valueFactory"/>.
+        /// </summary>
+        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
+        /// <param name="valueFactory">The asynchronous function used to generate a value to insert into cache.</param>
+        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
+        /// <returns>
+        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
+        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
+        /// </returns>
+        public virtual Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy)
+        {
+            var provider = ResolveProvider();
+            var item = provider.GetOrAddAsync(cacheKey, valueFactory, cachePolicy);
+
+            return item;
+        }
 
         /// <summary>
         /// Removes a cache entry from the cache. 
diff --git a/Source/EntityFramework.Extended/Caching/ICacheProvider.cs b/Source/EntityFramework.Extended/Caching/ICacheProvider.cs
index e945c36..0077ecc 100644
--- a/Source/EntityFramework.Extended/Caching/ICacheProvider.cs
+++ b/Source/EntityFramework.Extended/Caching/ICacheProvider.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace EntityFramework.Caching
 {
@@ -39,6 +40,18 @@ public interface ICacheProvider
         /// </returns>
         object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy);
 
+        /// <summary>
+        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned asynchronously by <paramref name="valueFactory"/>.
+        /// </summary>
+        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
+        /// <param name="valueFactory">The asynchronous function used to generate a value to insert into cache.</param>
+        /// <param name="cachePolicy">A <see cref="CachePolicy"/> that contains eviction details for the cache entry.</param>
+        /// <returns>
+        /// The value for the key. This will be either the existing value for the key if the key is already in the cache, 
+        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the cache.
+        /// </returns>
+        Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy);
+
         /// <summary>
         /// Removes a cache entry from the cache. 
         /// </summary>
diff --git a/Source/EntityFramework.Extended/Caching/MemoryCacheProvider.cs b/Source/EntityFramework.Extended/Caching/MemoryCacheProvider.cs
index 8992548..89e58f6 100644
--- a/Source/EntityFramework.Extended/Caching/MemoryCacheProvider.cs
+++ b/Source/EntityFramework.Extended/Caching/MemoryCacheProvider.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.Caching;
+using System.Threading.Tasks;
 
 namespace EntityFramework.Caching
 {
@@ -76,6 +77,37 @@ public object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, C
             return value;
         }
 
+        /// <summary>
+        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned asynchronously by <paramref name="valueFactory"/>.
+        /// </summary>
+        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
+        /// <param name="valueFactory">The asynchronous function used to generate a value to insert into cache.</param>
+        /// <param name="cachePolicy">A <see cref="CachePolicy"/> that contains eviction details for the cache entry.</param>
+        /// <returns>
+        /// The value for the key. This will be either the existing value for the key if the key is already in the cache,
+        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the cache.
+        /// </returns>
+        public async Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy)
+        {
+            var key = GetKey(cacheKey);
+            var cachedResult = MemoryCache.Default.Get(key);
+
+            if (cachedResult != null)
+            {
+                Debug.WriteLine("Cache Hit : " + key);
+                return cachedResult;
+            }
+
+            Debug.WriteLine("Cache Miss: " + key);
+
+            // get value and add to cache, not bothered
+            // if it succeeds or not just rerturn the value
+            var value = await valueFactory(cacheKey);
+            this.Add(cacheKey, value, cachePolicy);
+
+            return value;
+        }
+
         /// <summary>
         /// Removes a cache entry from the cache.
         /// </summary>
diff --git a/Source/EntityFramework.Extended/Extensions/BatchExtensions.cs b/Source/EntityFramework.Extended/Extensions/BatchExtensions.cs
index 29339cb..95e7b4a 100644
--- a/Source/EntityFramework.Extended/Extensions/BatchExtensions.cs
+++ b/Source/EntityFramework.Extended/Extensions/BatchExtensions.cs
@@ -3,6 +3,7 @@
 using System.Data.Entity.Core.Objects;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Threading.Tasks;
 using EntityFramework.Batch;
 using EntityFramework.Mapping;
 
@@ -66,6 +67,38 @@ public static int Delete<TEntity>(
             return source.Where(filterExpression).Delete();
         }
 
+        /// <summary>
+        /// Executes a delete statement asynchronously using an expression to filter the rows to be deleted.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="source">The source used to determine the table to delete from.</param>
+        /// <param name="filterExpression">The filter expression used to generate the where clause for the delete statement.</param>
+        /// <returns>The number of row deleted.</returns>
+        /// <example>Delete all users with email domain @test.com.
+        /// <code><![CDATA[
+        /// var db = new TrackerContext();
+        /// string emailDomain = "@test.com";
+        /// int count = db.Users.Delete(u => u.Email.EndsWith(emailDomain));
+        /// ]]></code>
+        /// </example>
+        /// <remarks>
+        /// When executing this method, the statement is immediately executed on the database provider
+        /// and is not part of the change tracking system.  Also, changes will not be reflected on 
+        /// any entities that have already been materialized in the current context.        
+        /// </remarks>
+        public static Task<int> DeleteAsync<TEntity>(
+            this IQueryable<TEntity> source,
+            Expression<Func<TEntity, bool>> filterExpression)
+            where TEntity : class
+        {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (filterExpression == null)
+                throw new ArgumentNullException("filterExpression");
+
+            return source.Where(filterExpression).DeleteAsync();
+        }
+
         /// <summary>
         /// Executes a delete statement using the query to filter the rows to be deleted.
         /// </summary>
@@ -102,7 +135,44 @@ public static int Delete<TEntity>(this IQueryable<TEntity> source)
             var runner = ResolveRunner();
             return runner.Delete(objectContext, entityMap, sourceQuery);
         }
-        
+
+        /// <summary>
+        /// Executes a delete statement asynchronously using the query to filter the rows to be deleted.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="source">The <see cref="IQueryable`1"/> used to generate the where clause for the delete statement.</param>
+        /// <returns>The number of row deleted.</returns>
+        /// <example>Delete all users with email domain @test.com.
+        /// <code><![CDATA[
+        /// var db = new TrackerContext();
+        /// string emailDomain = "@test.com";
+        /// int count = db.Users.Where(u => u.Email.EndsWith(emailDomain)).Delete();
+        /// ]]></code>
+        /// </example>
+        /// <remarks>
+        /// When executing this method, the statement is immediately executed on the database provider
+        /// and is not part of the change tracking system.  Also, changes will not be reflected on 
+        /// any entities that have already been materialized in the current context.        
+        /// </remarks>
+        public static Task<int> DeleteAsync<TEntity>(this IQueryable<TEntity> source)
+            where TEntity : class
+        {
+            ObjectQuery<TEntity> sourceQuery = source.ToObjectQuery();
+            if (sourceQuery == null)
+                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "source");
+
+            ObjectContext objectContext = sourceQuery.Context;
+            if (objectContext == null)
+                throw new ArgumentException("The ObjectContext for the source query can not be null.", "source");
+
+            EntityMap entityMap = sourceQuery.GetEntityMap<TEntity>();
+            if (entityMap == null)
+                throw new ArgumentException("Could not load the entity mapping information for the query ObjectSet.", "source");
+
+            var runner = ResolveRunner();
+            return runner.DeleteAsync(objectContext, entityMap, sourceQuery);
+        }
+
         /// <summary>
         /// The API was refactored to no longer need this extension method. Use query.Where(expression).Update(updateExpression) syntax instead.
         /// </summary>
@@ -186,6 +256,42 @@ public static int Update<TEntity>(
             return source.Where(filterExpression).Update(updateExpression);
         }
 
+        /// <summary>
+        /// Executes an update statement asynchronously using an expression to filter the rows that are updated.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="source">The source used to determine the table to update.</param>
+        /// <param name="filterExpression">The filter expression used to generate the where clause.</param>
+        /// <param name="updateExpression">The <see cref="MemberInitExpression"/> used to indicate what is updated.</param>
+        /// <returns>The number of row updated.</returns>
+        /// <example>Update all users in the test.com domain to be inactive.
+        /// <code><![CDATA[
+        /// var db = new TrackerContext();
+        /// string emailDomain = "@test.com";
+        /// int count = db.Users.Update(
+        ///   u => u.Email.EndsWith(emailDomain),
+        ///   u => new User { IsApproved = false, LastActivityDate = DateTime.Now });
+        /// ]]></code>
+        /// </example>
+        /// <remarks>
+        /// When executing this method, the statement is immediately executed on the database provider
+        /// and is not part of the change tracking system.  Also, changes will not be reflected on 
+        /// any entities that have already been materialized in the current context.        
+        /// </remarks>
+        public static Task<int> UpdateAsync<TEntity>(
+            this IQueryable<TEntity> source,
+            Expression<Func<TEntity, bool>> filterExpression,
+            Expression<Func<TEntity, TEntity>> updateExpression)
+            where TEntity : class
+        {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (filterExpression == null)
+                throw new ArgumentNullException("filterExpression");
+
+            return source.Where(filterExpression).UpdateAsync(updateExpression);
+        }
+
         /// <summary>
         /// Executes an update statement using the query to filter the rows to be updated.
         /// </summary>
@@ -233,6 +339,53 @@ public static int Update<TEntity>(
             return runner.Update(objectContext, entityMap, sourceQuery, updateExpression);
         }
 
+        /// <summary>
+        /// Executes an update statement asynchronously using the query to filter the rows to be updated.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the entity.</typeparam>
+        /// <param name="source">The query used to generate the where clause.</param>
+        /// <param name="updateExpression">The <see cref="MemberInitExpression"/> used to indicate what is updated.</param>
+        /// <returns>The number of row updated.</returns>
+        /// <example>Update all users in the test.com domain to be inactive.
+        /// <code><![CDATA[
+        /// var db = new TrackerContext();
+        /// string emailDomain = "@test.com";
+        /// int count = db.Users
+        ///   .Where(u => u.Email.EndsWith(emailDomain))
+        ///   .Update(u => new User { IsApproved = false, LastActivityDate = DateTime.Now });
+        /// ]]></code>
+        /// </example>
+        /// <remarks>
+        /// When executing this method, the statement is immediately executed on the database provider
+        /// and is not part of the change tracking system.  Also, changes will not be reflected on 
+        /// any entities that have already been materialized in the current context.        
+        /// </remarks>
+        public static Task<int> UpdateAsync<TEntity>(
+            this IQueryable<TEntity> source,
+            Expression<Func<TEntity, TEntity>> updateExpression)
+            where TEntity : class
+        {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (updateExpression == null)
+                throw new ArgumentNullException("updateExpression");
+
+            ObjectQuery<TEntity> sourceQuery = source.ToObjectQuery();
+            if (sourceQuery == null)
+                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "source");
+
+            ObjectContext objectContext = sourceQuery.Context;
+            if (objectContext == null)
+                throw new ArgumentException("The ObjectContext for the query can not be null.", "source");
+
+            EntityMap entityMap = sourceQuery.GetEntityMap<TEntity>();
+            if (entityMap == null)
+                throw new ArgumentException("Could not load the entity mapping information for the source.", "source");
+
+            var runner = ResolveRunner();
+            return runner.UpdateAsync(objectContext, entityMap, sourceQuery, updateExpression);
+        }
+
         private static IBatchRunner ResolveRunner()
         {
             var provider = Locator.Current.Resolve<IBatchRunner>();
diff --git a/Source/EntityFramework.Extended/Extensions/CacheExtensions.cs b/Source/EntityFramework.Extended/Extensions/CacheExtensions.cs
index 487deaf..75623cd 100644
--- a/Source/EntityFramework.Extended/Extensions/CacheExtensions.cs
+++ b/Source/EntityFramework.Extended/Extensions/CacheExtensions.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Data.Entity;
 using System.Text;
+using System.Threading.Tasks;
 using EntityFramework.Caching;
 
 namespace EntityFramework.Extensions
@@ -23,7 +24,7 @@ public static class CacheExtensions
         /// <returns>
         /// The result of the query.
         /// </returns>
-        public static IEnumerable<TEntity> FromCache<TEntity>(this IQueryable<TEntity> query, CachePolicy cachePolicy = null, IEnumerable<string> tags = null)
+        public static IList<TEntity> FromCache<TEntity>(this IQueryable<TEntity> query, CachePolicy cachePolicy = null, IEnumerable<string> tags = null)
             where TEntity : class
         {
             string key = query.GetCacheKey();
@@ -37,7 +38,37 @@ public static IEnumerable<TEntity> FromCache<TEntity>(this IQueryable<TEntity> q
                 cacheKey,
                 k => query.AsNoTracking().ToList(),
                 cachePolicy ?? CachePolicy.Default
-            ) as IEnumerable<TEntity>;
+            ) as IList<TEntity>;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Returns the result of the <paramref name="query"/>; if possible from the cache,
+        /// otherwise the query is materialized asynchronously and the result cached before being returned.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the data in the data source.</typeparam>
+        /// <param name="query">The query to be materialized.</param>
+        /// <param name="cachePolicy">The cache policy for the query.</param>
+        /// <param name="tags">The list of tags to use for cache expiration.</param>
+        /// <returns>
+        /// The result of the query.
+        /// </returns>
+        public static async Task<IList<TEntity>> FromCacheAsync<TEntity>(this IQueryable<TEntity> query, CachePolicy cachePolicy = null, IEnumerable<string> tags = null)
+            where TEntity : class
+        {
+            string key = query.GetCacheKey();
+            var cacheKey = new CacheKey(key,
+                tags ?? Enumerable.Empty<string>());
+
+            // allow override of CacheManager
+            var manager = Locator.Current.Resolve<CacheManager>();
+
+            var result = await manager.GetOrAddAsync(
+                cacheKey,
+                async k => await query.AsNoTracking().ToListAsync(),
+                cachePolicy ?? CachePolicy.Default
+            ) as IList<TEntity>;
 
             return result;
         }
@@ -60,6 +91,24 @@ public static TEntity FromCacheFirstOrDefault<TEntity>(this IQueryable<TEntity>
                 .FirstOrDefault();
         }
 
+        /// <summary>
+        /// Returns the first element of the <paramref name="query"/>; if possible from the cache,
+        /// otherwise the query is materialized asynchronously and the result cached before being returned.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the data in the data source.</typeparam>
+        /// <param name="query">The query to be materialized.</param>
+        /// <param name="cachePolicy">The cache policy for the query.</param>
+        /// <param name="tags">The list of tags to use for cache expiration.</param>
+        /// <returns>default(T) if source is empty; otherwise, the first element in source.</returns>
+        public static async Task<TEntity> FromCacheFirstOrDefaultAsync<TEntity>(this IQueryable<TEntity> query, CachePolicy cachePolicy = null, IEnumerable<string> tags = null)
+            where TEntity : class
+        {
+            return (await query
+                .Take(1)
+                .FromCacheAsync(cachePolicy, tags)
+                ).FirstOrDefault();
+        }
+
         /// <summary>
         /// Removes the cached query from cache.
         /// </summary>