Class QueryDeferredExtensions

A class that contains various extension methods from Entity Framework with deferred implementations.

Inheritance

System.Object

QueryDeferredExtensions

Namespace:

Assembly: Alachisoft.NCache.EntityFrameworkCore.dll

Syntax

public static class QueryDeferredExtensions : object

Methods

Name	Description
DeferredAggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource, TSource, TSource>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Aggregate" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAggregate<TSource, TAccumulate>(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate, TSource, TAccumulate>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Aggregate" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAggregate<TSource, TAccumulate, TResult>(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate, TSource, TAccumulate>>, Expression<Func<TAccumulate, TResult>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Aggregate" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAll<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "All" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAny<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Any" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAny<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Any" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Decimal>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Double>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Int32>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Int64>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Nullable<Decimal>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Nullable<Double>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Nullable<Int32>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Nullable<Int64>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Nullable<Single>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage(IQueryable<Single>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Decimal>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Double>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Int32>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Int64>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Decimal>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Double>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Int32>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Int64>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Single>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredAverage<TSource>(IQueryable<TSource>, Expression<Func<TSource, Single>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Average" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredContains<TSource>(IQueryable<TSource>, TSource)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Contains" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredContains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Contains" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredCount<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Count" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredCount<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Count" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredElementAt<TSource>(IQueryable<TSource>, Int32)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "ElementAt" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredElementAtOrDefault<TSource>(IQueryable<TSource>, Int32)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "ElementAtOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredFirst<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "First" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredFirst<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "First" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredFirstOrDefault<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "FirstOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredFirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "FirstOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLast<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Last" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLast<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Last" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLastOrDefault<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "LastOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLastOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "LastOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLongCount<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "LongCount" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredLongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "LongCount" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredMax<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Max" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredMax<TSource, TResult>(IQueryable<TSource>, Expression<Func<TSource, TResult>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Max" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredMin<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Min" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredMin<TSource, TResult>(IQueryable<TSource>, Expression<Func<TSource, TResult>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Min" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "SequenceEqual" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "SequenceEqual" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSingle<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Single" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSingle<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Single" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSingleOrDefault<TSource>(IQueryable<TSource>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "SingleOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource, Boolean>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "SingleOrDefault" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Decimal>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Double>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Int32>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Int64>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Nullable<Decimal>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Nullable<Double>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Nullable<Int32>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Nullable<Int64>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Nullable<Single>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum(IQueryable<Single>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Decimal>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Double>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Int32>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Int64>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Decimal>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Double>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Int32>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Int64>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Nullable<Single>>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.
DeferredSum<TSource>(IQueryable<TSource>, Expression<Func<TSource, Single>>)	This method is the deferred implementation of the extension method . In EF some linq operations are performed on the client end instead of the server. Therefore, if we use the regular method it will cache the data from the database before performing the actual "Sum" operation. To cater to this, we provide with a deferred implementation that delays the caching so that only the result can be cached.