public void ProjectingEnumToString()
{
var customers = new[] { new Customer() { FirstName = "Bill", LastName = "White", CustomerType = CustomerType.Vip } }.AsQueryable();
var projected = customers.ProjectTo<CustomerDto>(_mapper.ConfigurationProvider);
projected.ShouldNotBeNull();
Assert.Equal(customers.Single().CustomerType.ToString().ToUpper(), projected.Single().CustomerType);
}
public void ProjectingEnumToString()
{
var customers = new[] { new Customer() { FirstName = "Bill", LastName = "White", CustomerType = CustomerType.Vip } }.AsQueryable();
var projected = Mapper.Map<CustomerDto[]>(customers);
projected.ShouldNotBeNull();
Assert.Equal(customers.Single().CustomerType.ToString().ToUpper(), projected.Single().CustomerType);
}
private IQueryable <Officer> GetFilteredQuery(GetOfficerInput input)
{
var query = QueryableExtensions.WhereIf(_officerRepository.GetAll()
.Include(x => x.Contractor)
.Include(x => x.StateInfo),
!input.Filter.IsNullOrWhiteSpace(), u =>
u.Name.Contains(input.Filter) ||
u.Family.Contains(input.Filter) ||
u.NationalCode.Replace("-", "").Contains(input.Filter) ||
u.MobileNumber.Replace("-", "").Contains(input.Filter) ||
u.Contractor.Name.Contains(input.Filter) ||
u.Contractor.Family.Contains(input.Filter) ||
u.Contractor.FirmName.Contains(input.Filter) ||
u.StateInfo.Name.Contains(input.Filter) ||
u.Code.Contains(input.Filter));
return(query);
}
public void StartRows(int start, int rows, int ExpectedFirstIndex)
{
//arrange
var testobjCollection = GetTestObjectCollection();
var source = testobjCollection.AsQueryable();
var pagingOptions = new PagingOptions()
{
Start = start, Rows = rows
};
//act
var actual = QueryableExtensions.AddPaging(source, pagingOptions).ToList();
//assert
actual.Should().HaveElementAt(0, new TestObject {
Index = ExpectedFirstIndex, String = ExpectedFirstIndex.ToString()
});
//actual.Should().HaveElementAt(0, testobjCollection[ExpectedFirstIndex]);
}
public static IQueryable <TInput> Include <TInput>(this IQueryable <TInput> query, params Expression <Func <TInput, object> >[] IncludeParas)
{
List <string> IncludeList = new List <string>();
foreach (var item in IncludeParas)
{
var property = item.Body as MemberExpression;
if (property == null)
{
throw new Exception(string.Format("无效的表达式({0})!", item.Body.ToString()));
}
if (!property.Type.IsClass)
{
throw new Exception(string.Format("类型{0}必须为引用类型", property.Type.Name));
}
IncludeList.Add(property.Member.Name);
}
query = QueryableExtensions.Include(query, string.Join(",", IncludeList));
return(query);
}
private IQueryable <PlaqueChange> GetFilteredQuery(GetPlaqueChangeInput input)
{
long tempSearch = Convert.ToInt64(input.Filter);
var query = QueryableExtensions.WhereIf(
_plaqueChangeRepository.GetAll()
.Include(x => x.Plaque)
.ThenInclude(x => x.Livestock)
.ThenInclude(x => x.Herd)
.Include(x => x.PreState)
.Include(x => x.NewState)
.Include(x => x.Officer),
!input.Filter.IsNullOrWhiteSpace(), u =>
u.Plaque.Code.ToString().Contains(input.Filter) ||
u.Plaque.Livestock.Herd.HerdName.Contains(input.Filter) ||
u.PreState.Name.Contains(input.Filter) ||
u.NewState.Name.Contains(input.Filter) ||
u.Officer.Name.Contains(input.Filter) ||
u.Officer.Family.Contains(input.Filter));
return(query);
}
private IQueryable <Insemination> GetFilteredQuery(GetInseminationInput input)
{
var query = QueryableExtensions.WhereIf(
_inseminationRepository.GetAll()
.Include(x => x.SpeciesInfo)
.Include(x => x.SexInfo)
.Include(x => x.Herd)
.Include(x => x.ActivityInfo)
.Include(x => x.Officer),
!input.Filter.IsNullOrWhiteSpace(), u =>
u.NationalCode.Contains(input.Filter) ||
u.SpeciesInfo.Name.Contains(input.Filter) ||
u.Herd.HerdName.Contains(input.Filter) ||
u.Herd.Name.Contains(input.Filter) ||
u.Herd.Family.Contains(input.Filter) ||
u.ActivityInfo.Name.Contains(input.Filter) ||
u.Officer.Name.Contains(input.Filter) ||
u.Officer.Family.Contains(input.Filter));
return(query);
}
public void DynamicExpressions_TypeConversions(string filterstring, bool shouldContain1111, bool shouldContain9911, string expectedIds)
{
//arrange
var items = filterstring.Split('&').Select(_ => { var t = _.Split('='); return(new KeyValuePair <string, string>(t[0], t[1])); });
var filterOps = new FilterOptionsParser().Parse(items);
var testObjList = CreateTestData();
var byKeys = testObjList.ToDictionary(_ => _.IdStr);
//act
var actual = QueryableExtensions.AddFilters(testObjList.AsQueryable(), filterOps)
.ToList(); //run the query
//assert
var expectedIdsList = expectedIds.Split(',');
actual.Should().HaveCount(expectedIdsList.Count());
if (shouldContain1111)
{
actual.Should().Contain(byKeys["1111"]);
}
else
{
actual.Should().NotContain(byKeys["1111"]);
}
if (shouldContain9911)
{
actual.Should().Contain(byKeys["9911"]);
}
else
{
actual.Should().NotContain(byKeys["9911"]);
}
//actual.Should().ContainInOrder(expectedIdsList.ToArray());
}
private IQueryable <Contractor> GetFilteredQuery(GetContractorInput input)
{
var query = QueryableExtensions.WhereIf(
_contractorRepository.GetAll()
.Include(x => x.FirmType)
.Include(x => x.StateInfo)
.Include(x => x.CityInfo)
.Include(x => x.RegionInfo)
.Include(x => x.VillageInfo)
.Include(x => x.UnionInfo),
!input.Filter.IsNullOrWhiteSpace(), u =>
u.Name.Contains(input.Filter) ||
u.Family.Contains(input.Filter) ||
u.StateInfo.Name.Contains(input.Filter) ||
u.CityInfo.Name.Contains(input.Filter) ||
u.RegionInfo.Name.Contains(input.Filter) ||
u.VillageInfo.Name.Contains(input.Filter) ||
u.UnionInfo.UnionName.Contains(input.Filter) ||
u.NationalCode.Replace("-", "").Contains(input.Filter) ||
u.FirmName.Contains(input.Filter) ||
u.Code.Contains(input.Filter));
return(query);
}
public Task <PagedList <Category> > GetCategoriesAsync(CategoriesResourceParameters categoriesResourceParameters)
{
var collectionBeforePaging =
QueryableExtensions.ApplySort(_categoryRepository
.FindAllCategoriesPagedOf(categoriesResourceParameters.PageIndex,
categoriesResourceParameters.PageSize),
categoriesResourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <CategoryUiModel, Category>());
if (!string.IsNullOrEmpty(categoriesResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = categoriesResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging.QueriedItems = collectionBeforePaging.QueriedItems
.Where(a => a.Name.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(Task.Run(() => PagedList <Category> .Create(collectionBeforePaging,
categoriesResourceParameters.PageIndex,
categoriesResourceParameters.PageSize)));
}
public async Task <PagedResultDto <MonitoringListDto> > GetMonitoring(GetMonitoringInput input)
{
var query = QueryableExtensions.WhereIf(
_livestockRepository.GetAll()
.Include(x => x.SpeciesInfo)
.Include(x => x.Herd)
.ThenInclude(x => x.Contractor)
.Include(x => x.Officer),
!input.Filter.IsNullOrWhiteSpace(), u =>
u.CreationTime >= DateTime.Parse(input.Filter));
var userCount = await query.CountAsync();
var monitorings = await query
.OrderBy(input.Sorting)
.PageBy(input)
.ToListAsync();
var monitoringsListDto = ObjectMapper.Map <List <MonitoringListDto> >(monitorings);
return(new PagedResultDto <MonitoringListDto>(
userCount,
monitoringsListDto
));
}
private IQueryable <PlaqueToState> GetFilteredQuery(GetPlaqueToStateInput input)
{
long tempSearch = 0;
try
{
tempSearch = Convert.ToInt64(input.Filter);
}
catch (Exception e)
{
}
var query = QueryableExtensions.WhereIf(
_plaqueToStateRepository.GetAll()
.Include(x => x.StateInfo)
.Include(x => x.PlaqueStore)
.ThenInclude(x => x.Species),
!input.Filter.IsNullOrWhiteSpace(), u =>
(u.FromCode <= tempSearch &&
u.ToCode >= tempSearch) ||
u.StateInfo.Name.Contains(input.Filter) ||
u.PlaqueStore.Species.Name.Contains(input.Filter));
return(query);
}
public Task <PagedList <User> > GetUsersAsync(UsersResourceParameters personsResourceParameters)
{
var collectionBeforePaging =
QueryableExtensions.ApplySort(_personRepository
.GetUsersPagedAsync(personsResourceParameters.PageIndex,
personsResourceParameters.PageSize),
personsResourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <UserUiModel, User>());
if (!string.IsNullOrEmpty(personsResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = personsResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging.QueriedItems = collectionBeforePaging.QueriedItems
.Where(a => a.Login.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(Task.Run(() => PagedList <User> .Create(collectionBeforePaging,
personsResourceParameters.PageIndex,
personsResourceParameters.PageSize)));
}
/// <summary>
/// Obtiene los banners RSS activos en una fecha y rango de hora específico
/// </summary>
/// <param name="pDate">Fecha a buscar</param>
/// <param name="pTimeFrom">Inicio de intervalo de tiempo</param>
/// <param name="pTimeTo">Fin de intervalo de tiempo</param>
/// <returns>Lista de banners RSS activos en el horario y fecha dados</returns>
public IEnumerable<RssBanner> GetActives(DateTime pDate, TimeSpan pTimeFrom, TimeSpan pTimeTo)
{
if (pDate == null)
throw new ArgumentNullException("pDate");
if (pTimeFrom == null)
throw new ArgumentNullException("pTimeFrom");
if (pTimeTo == null)
throw new ArgumentNullException("pTimeTo");
if (pTimeFrom.CompareTo(pTimeTo) > -1)
throw new InvalidOperationException("pTimeFrom debe ser menor que pTimeTo");
cLogger.Info("Obteniendo Banners RSS activos");
IQueryable<RssBanner> query = from rssBanner in this.iDbContext.Set<RssBanner>()
where
//La fecha actual esta entre la fecha de inicio y fin del banner
(rssBanner.initDate <= pDate && rssBanner.endDate >= pDate)
&&
//El banner empieza antes del fin del intervalo y termina despues del principio del intervalo
(rssBanner.initTime <= pTimeTo && rssBanner.endTime >= pTimeFrom)
select rssBanner;
return QueryableExtensions.Include(query, "items");
}
public static Task <bool> AnyAsync <TSource>(this IQueryable <TSource> source,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.AnyAsync(source, cancellationToken));
}
public static Task <TSource> SingleOrDefaultAsync <TSource>(this IQueryable <TSource> source,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.SingleOrDefaultAsync(source, cancellationToken));
}
public static Task <bool> AllAsync <TSource>(this IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.AllAsync(source, predicate, cancellationToken));
}
public static Task <Dictionary <TKey, TElement> > ToDictionaryAsync <TSource, TKey, TElement>(this IQueryable <TSource> source, Func <TSource, TKey> keySel, Func <TSource, TElement> elemSel,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.ToDictionaryAsync(source, keySel, elemSel, cancellationToken));
}
public static Task <List <TSource> > ToListAsync <TSource>(this IQueryable <TSource> source,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.ToListAsync(source, cancellationToken));
}
public static Task LoadAsync(this IQueryable source, CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.LoadAsync(source, cancellationToken));
}
public static Task <TResult> MinAsync <TSource, TResult>(this IQueryable <TSource> source, Expression <Func <TSource, TResult> > selector,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.MinAsync(source, selector, cancellationToken));
}
public static IQueryable AsNoTracking(this IQueryable source)
{
return(QueryableExtensions.AsNoTracking(source));
}
public static IQueryable <TSource> AsNoTracking <TSource>(this IQueryable <TSource> source) where TSource : class
{
return(QueryableExtensions.AsNoTracking(source));
}
public async Task TestAsync()
{
Assert.Equal(91, await QueryableExtensions.CountAsync(_context.Customers));
}
public static IQueryable <T> Include <T, TProperty>(this IQueryable <T> source,
Expression <Func <T, TProperty> > path)
{
return(QueryableExtensions.Include(source, path));
}
public async Task <IEnumerable <TEntity> > Get(Func <TEntity, bool> predicate)
{
return(await QueryableExtensions.ToListAsync(DbContext.Set <TEntity>().Where(predicate).AsQueryable()));
}
public async Task Extension_methods_validate_arguments()
{
// ReSharper disable AssignNullToNotNullAttribute
await ArgumentNullTest("source", () => QueryableExtensions.FirstAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.FirstAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().FirstAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.FirstOrDefaultAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.FirstOrDefaultAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().FirstOrDefaultAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.SingleAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.SingleAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().SingleAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.SingleOrDefaultAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.SingleOrDefaultAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().SingleOrDefaultAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.ContainsAsync(null, 1));
await ArgumentNullTest("source", () => QueryableExtensions.ContainsAsync(null, 1, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.AnyAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.AnyAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().AnyAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.AllAsync <int>(null, s => true));
await ArgumentNullTest("source", () => QueryableExtensions.AllAsync <int>(null, s => true, new CancellationToken()));
await ArgumentNullTest("predicate", () => Source().AllAsync(null));
await ArgumentNullTest("predicate", () => Source().AllAsync(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.CountAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.CountAsync <int>(null, s => true));
await ArgumentNullTest("predicate", () => Source().CountAsync(null));
await ArgumentNullTest("source", () => QueryableExtensions.LongCountAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.LongCountAsync <int>(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.LongCountAsync <int>(null, s => true));
await ArgumentNullTest("source", () => QueryableExtensions.LongCountAsync <int>(null, s => true, new CancellationToken()));
await ArgumentNullTest("predicate", () => Source().LongCountAsync(null));
await ArgumentNullTest("predicate", () => Source().LongCountAsync(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.MinAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.MinAsync <int>(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.MinAsync <int, bool>(null, s => true));
await ArgumentNullTest("source", () => QueryableExtensions.MinAsync <int, bool>(null, s => true, new CancellationToken()));
await ArgumentNullTest("selector", () => Source().MinAsync <int, bool>(null));
await ArgumentNullTest("selector", () => Source().MinAsync <int, bool>(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.MaxAsync <int>(null));
await ArgumentNullTest("source", () => QueryableExtensions.MaxAsync <int>(null, new CancellationToken()));
await ArgumentNullTest("source", () => QueryableExtensions.MaxAsync <int, bool>(null, s => true));
await ArgumentNullTest("source", () => QueryableExtensions.MaxAsync <int, bool>(null, s => true, new CancellationToken()));
await ArgumentNullTest("selector", () => Source().MaxAsync <int, bool>(null));
await ArgumentNullTest("selector", () => Source().MaxAsync <int, bool>(null, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync());
await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <int>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <long>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <float>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <double>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).SumAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <int>().SumAsync((Expression <Func <int, int> >)null));
await ArgumentNullTest("selector", () => Source <int?>().SumAsync((Expression <Func <int?, int> >)null));
await ArgumentNullTest("selector", () => Source <long>().SumAsync((Expression <Func <long, int> >)null));
await ArgumentNullTest("selector", () => Source <long?>().SumAsync((Expression <Func <long?, int> >)null));
await ArgumentNullTest("selector", () => Source <float>().SumAsync((Expression <Func <float, int> >)null));
await ArgumentNullTest("selector", () => Source <float?>().SumAsync((Expression <Func <float?, int> >)null));
await ArgumentNullTest("selector", () => Source <double>().SumAsync((Expression <Func <double, int> >)null));
await ArgumentNullTest("selector", () => Source <double?>().SumAsync((Expression <Func <double?, int> >)null));
await ArgumentNullTest("selector", () => Source <decimal>().SumAsync((Expression <Func <decimal, int> >)null));
await ArgumentNullTest("selector", () => Source <decimal?>().SumAsync((Expression <Func <decimal?, int> >)null));
await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync());
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <int>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <int?>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <long>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <long?>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <float>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <float?>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <double>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <double?>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <decimal>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(i => 0));
await ArgumentNullTest("source", () => ((IQueryable <decimal?>)null).AverageAsync(i => 0, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <int>().AverageAsync((Expression <Func <int, int> >)null));
await ArgumentNullTest("selector", () => Source <int>().AverageAsync((Expression <Func <int, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <int?>().AverageAsync((Expression <Func <int?, int> >)null));
await ArgumentNullTest("selector", () => Source <int?>().AverageAsync((Expression <Func <int?, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <long>().AverageAsync((Expression <Func <long, int> >)null));
await ArgumentNullTest("selector", () => Source <long>().AverageAsync((Expression <Func <long, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <long?>().AverageAsync((Expression <Func <long?, int> >)null));
await ArgumentNullTest("selector", () => Source <long?>().AverageAsync((Expression <Func <long?, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <float>().AverageAsync((Expression <Func <float, int> >)null));
await ArgumentNullTest("selector", () => Source <float>().AverageAsync((Expression <Func <float, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <float?>().AverageAsync((Expression <Func <float?, int> >)null));
await ArgumentNullTest("selector", () => Source <float?>().AverageAsync((Expression <Func <float?, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <double>().AverageAsync((Expression <Func <double, int> >)null));
await ArgumentNullTest("selector", () => Source <double>().AverageAsync((Expression <Func <double, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <double?>().AverageAsync((Expression <Func <double?, int> >)null));
await ArgumentNullTest("selector", () => Source <double?>().AverageAsync((Expression <Func <double?, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <decimal>().AverageAsync((Expression <Func <decimal, int> >)null));
await ArgumentNullTest("selector", () => Source <decimal>().AverageAsync((Expression <Func <decimal, int> >)null, new CancellationToken()));
await ArgumentNullTest("selector", () => Source <decimal?>().AverageAsync((Expression <Func <decimal?, int> >)null));
await ArgumentNullTest("selector", () => Source <decimal?>().AverageAsync((Expression <Func <decimal?, int> >)null, new CancellationToken()));
// ReSharper restore AssignNullToNotNullAttribute
}
public static Task <decimal?> SumAsync(this IQueryable <decimal?> source, CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.SumAsync(source, cancellationToken));
}
public static IQueryable <T> Include <T>(this IQueryable <T> source, string path)
{
return(QueryableExtensions.Include(source, path));
}
public static Task <bool> ContainsAsync <TSource>(this IQueryable <TSource> source, TSource item,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.ContainsAsync(source, item, cancellationToken));
}
public static Task <List <TEntity> > ToListAsync <TEntity>(this IQueryable <TEntity> query) where TEntity : class
{
return(QueryableExtensions.ToListAsync(query));
}
public static Task ForEachAsync <TSource>(this IQueryable <TSource> source, Action <TSource> action,
CancellationToken cancellationToken = new CancellationToken())
{
return(QueryableExtensions.ForEachAsync(source, action, cancellationToken));
}
