private async Task <TResult> GetSumAsync <TResult>(IQueryable <TResult> newSource) { var results = await GetStaticDataAsync <TResult>(x => EntityFrameworkQueryableExtensions.SumAsync((dynamic)x), newSource); return(Enumerable.Sum((dynamic)results)); }
public Task <Dictionary <TKey, TElement> > ToDictionaryAsync <TSource, TKey, TElement>( IQueryable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, CancellationToken token) => EntityFrameworkQueryableExtensions.ToDictionaryAsync(source, keySelector, elementSelector, token);
public Task <TSource> SingleOrDefaultAsync <TSource>( IQueryable <TSource> source, CancellationToken token) => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, token);
public Task <double?> SumAsync <TSource>( IQueryable <TSource> source, Expression <Func <TSource, double?> > selector, CancellationToken token) => EntityFrameworkQueryableExtensions.SumAsync(source, selector, token);
public Task <Dictionary <TKey, TSource> > ToDictionaryAsync <TSource, TKey>( IQueryable <TSource> source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer, CancellationToken token) => EntityFrameworkQueryableExtensions.ToDictionaryAsync(source, keySelector, comparer, token);
public Task <long> LongCountAsync <TSource>( IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate, CancellationToken token) => EntityFrameworkQueryableExtensions.LongCountAsync(source, predicate, token);
public Task <TResult> MaxAsync <TSource, TResult>( IQueryable <TSource> source, Expression <Func <TSource, TResult> > selector, CancellationToken token) => EntityFrameworkQueryableExtensions.MaxAsync(source, selector, token);
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> query, Expression <Func <T, bool> > predicate) { return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(query, predicate)); }
public Task <long> LongCountAsync <T>(IQueryable <T> query) { return(EntityFrameworkQueryableExtensions.LongCountAsync(query)); }
public Task <int> CountAsync <T>(IQueryable <T> query) { return(EntityFrameworkQueryableExtensions.CountAsync(query)); }
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> query) { return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(query)); }
public IEnumerable <Broker> GetAllWithReferenceData() { return(EntityFrameworkQueryableExtensions.Include <Broker, ICollection <Exchange> >(context.Brokers, x => x.Exchanges).ThenInclude(y => y.Currency).ToList()); }
public static IQueryable <TEntity> Include <TEntity>(this IQueryable <TEntity> queryable, string prop) where TEntity : class { return(EntityFrameworkQueryableExtensions.Include <TEntity>(queryable, navigationPropertyPath: prop)); }
public static IQueryable <TEntity> Include <TEntity, TProperty>(this IQueryable <TEntity> queryable, Expression <Func <TEntity, TProperty> > predicate) where TEntity : class where TProperty : class { return(EntityFrameworkQueryableExtensions.Include <TEntity, TProperty>(queryable, predicate)); }
public Task <bool> ContainsAsync <TSource>( IQueryable <TSource> source, TSource item, CancellationToken token) => EntityFrameworkQueryableExtensions.ContainsAsync(source, item, token);
public Task <TResult> MinAsync <TSource, TResult>(IQueryable <TSource> source, Expression <Func <TSource, TResult> > selector) { return(EntityFrameworkQueryableExtensions.MinAsync(source, selector)); }
public Task <long> LongCountAsync <TSource>( IQueryable <TSource> source, CancellationToken token) => EntityFrameworkQueryableExtensions.LongCountAsync(source, token);
public Task <T[]> ToArrayAsync <T>(IQueryable <T> query) { return(EntityFrameworkQueryableExtensions.ToArrayAsync(query)); }
public Task ForEachAsync <TSource>( IQueryable <TSource> source, Action <TSource> action, CancellationToken token) => EntityFrameworkQueryableExtensions.ForEachAsync(source, action, token);
public Task <List <T> > ToListAsync <T>(IQueryable <T> query) { return(EntityFrameworkQueryableExtensions.ToListAsync(query)); }
public Task <double?> SumAsync( IQueryable <double?> source, CancellationToken token) => EntityFrameworkQueryableExtensions.SumAsync(source, token);
public Task <decimal?> AverageAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, decimal?> > selector) { return(EntityFrameworkQueryableExtensions.AverageAsync(source, selector)); }
public Task <decimal?> AverageAsync( IQueryable <decimal?> source, CancellationToken token) => EntityFrameworkQueryableExtensions.AverageAsync(source, token);
public Task <double> SumAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, double> > selector) { return(EntityFrameworkQueryableExtensions.SumAsync(source, selector)); }
public Task <decimal?> AverageAsync <TSource>( IQueryable <TSource> source, Expression <Func <TSource, decimal?> > selector, CancellationToken token) => EntityFrameworkQueryableExtensions.AverageAsync(source, selector, token);
protected override async Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context) { //Get DbContext from DI container DbContext db = (DbContext)context.HttpContext.RequestServices.GetService(DbContextType); if (db == null) { throw new Exception("Database not found"); } //Get DbSet as IQueryable IQueryable query = (IQueryable)_dbContextSetMethod.MakeGenericMethod(ModelType).Invoke(db, null); if (!string.IsNullOrEmpty(RawSql)) { query = (IQueryable)RelationalQueryableExtensions.FromSql((dynamic)query, RawSql, RawSqlParameters); } if (!EnableChangeTracking) { query = (IQueryable)EntityFrameworkQueryableExtensions.AsNoTracking((dynamic)query); } if (context.SelectedOnly) { //Select by Id var whereClause = DbContextHelper.SearchForEntityByValues(ModelType, DataValueField, context.CurrentValues); query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause }); } else { if (context.ModelExplorer.Metadata is DefaultModelMetadata defaultModelMetadata) { //Loop over where clauses IEnumerable <SelectListDbWhereEqualsAttribute> whereClauseAttributes = null; if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Property) { whereClauseAttributes = defaultModelMetadata.Attributes.PropertyAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId); } else if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Type) { whereClauseAttributes = defaultModelMetadata.Attributes.TypeAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId); } if (whereClauseAttributes != null) { foreach (var where in whereClauseAttributes) { var whereClause = LamdaHelper.SearchForEntityByProperty(ModelType, where.PropertyName, where.Values); query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause }); } } } } //Order By if (!string.IsNullOrWhiteSpace(OrderByProperty)) { if (OrderByType == "asc") { query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, true }); } else { query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, false }); } } //Skip query = (IQueryable)Queryable.Skip((dynamic)query, Skip); //Take query = (IQueryable)Queryable.Take((dynamic)query, Take); //Get Results IEnumerable results = (IEnumerable)(await EntityFrameworkQueryableExtensions.ToListAsync((dynamic)query, CancellationToken.None)); return(new ModelMultiSelectList(context.Html, results, DataValueField, DataTextFieldExpression)); }
public Task <TSource> FirstAsync <TSource>( IQueryable <TSource> source, CancellationToken token) => EntityFrameworkQueryableExtensions.FirstAsync(source, token);
public async Task UpdateSde(bool tq = false) { MarketDB db = tq ? (MarketDB)_tqdb : _cndb; ESIClient esi = tq ? (ESIClient)_tqesi : _esi; var oldgroups = await EntityFrameworkQueryableExtensions.ToListAsync(db.marketgroup); var attr = esi.GetAllAttrs(); var allmarketgroupstask = esi.Get_markets_groupsAsync(); var alltypetask = GetAllTypeAsync(tq); var newmodels = new ConcurrentBag <EVEMarketSite.Model.marketgroup>(); var oldattr = await EntityFrameworkQueryableExtensions.ToListAsync(db.dogma_attributes); foreach (var m in await attr) { var model = oldattr.FirstOrDefault(p => p.attribute_id == m.Attribute_id); if (model == null) { model = new dogma_attributes(); db.dogma_attributes.Add(model); } model.attribute_id = m.Attribute_id; model.name = m.Name; model.description = m.Description; model.default_value = m.Default_value; model.display_name = m.Display_name; model.high_is_good = m.High_is_good; model.icon_id = m.Icon_id; model.published = m.Published; model.stackable = m.Stackable; model.unit_id = m.Unit_id; } List <marketgroup> cnMarketgroups = new List <marketgroup>(); List <evetypes> cntypes = new List <evetypes>(); if (tq) { cnMarketgroups = await _cndb.marketgroup.ToListAsync(); cntypes = await _cndb.evetypes.ToListAsync(); } await Dasync.Collections.ParallelForEachExtensions.ParallelForEachAsync((await allmarketgroupstask).Distinct(), async i => { while (true) { try { var groupinfo_en = esi.Get_markets_groups_market_group_idAsync("en-us", i); Task <Get_markets_groups_market_group_id_ok> groupinfo_cn; if (!tq) { groupinfo_cn = esi.Get_markets_groups_market_group_idAsync("zh", i); } else { var tmp = cnMarketgroups.FirstOrDefault(p => p.marketGroupID == i); if (tmp != null) { groupinfo_cn = Task.FromResult(new Get_markets_groups_market_group_id_ok() { Name = tmp.marketGroupName, Description = tmp.description, }); } else { groupinfo_cn = groupinfo_en; } } await Task.WhenAll(groupinfo_cn, groupinfo_en); _logger.LogDebug($"GetItemMarketGroupInfoV1Async {i}"); var oldmodel = oldgroups.FirstOrDefault(p => p.marketGroupID == i); if (oldmodel == null) { oldmodel = new marketgroup(); oldmodel.marketGroupID = i; newmodels.Add(oldmodel); } oldmodel.marketGroupName_en = groupinfo_en.Result.Name; oldmodel.marketGroupName = groupinfo_cn.Result.Name; oldmodel.description = groupinfo_cn.Result.Description; oldmodel.description_en = groupinfo_en.Result.Description; oldmodel.parentGroupID = groupinfo_en.Result.Parent_group_id; return; } catch (Exception e) { await Task.Delay(TimeSpan.FromSeconds(1)); _logger.LogWarning(e + ""); } } }, MAX_THREAD); db.marketgroup.AddRange(newmodels); _logger.LogDebug($"Save GetMarketItemGroupInfo"); await db.SaveChangesAsync(); _logger.LogDebug($"Save GetMarketItemGroupInfo OK"); await db.SaveChangesAsync(); var oldtypes = await EntityFrameworkQueryableExtensions.ToListAsync(db.evetypes); var oldtypeattr = await EntityFrameworkQueryableExtensions.ToListAsync(db.type_attributes); var newtypes = new ConcurrentBag <evetypes>(); var newtypeattrs = new ConcurrentBag <type_attributes>(); await Dasync.Collections.ParallelForEachExtensions.ParallelForEachAsync(await alltypetask, async i => { try { var groupinfo_en = esi.Get_universe_types_type_idAsync("en-us", i); Task <Get_universe_types_type_id_ok> groupinfo_cn; if (!tq) { groupinfo_cn = esi.Get_universe_types_type_idAsync("zh", i); } else { var tmp = cntypes.FirstOrDefault(p => p.typeID == i); if (tmp != null) { groupinfo_cn = Task.FromResult(new Get_universe_types_type_id_ok() { Name = tmp.typeName, Description = tmp.description, }); } else { groupinfo_cn = groupinfo_en; } } await Task.WhenAll(groupinfo_cn, groupinfo_en); _logger.LogDebug($"GetTypeInfoV3Async {i}"); var oldmodel = oldtypes.FirstOrDefault(p => p.typeID == i); if (oldmodel == null) { oldmodel = new evetypes(); oldmodel.typeID = i; newtypes.Add(oldmodel); } oldmodel.marketGroupID = groupinfo_en.Result.Market_group_id; oldmodel.portionSize = groupinfo_en.Result.Portion_size; oldmodel.published = groupinfo_en.Result.Published; oldmodel.mass = groupinfo_en.Result.Mass; oldmodel.capacity = groupinfo_en.Result.Capacity; oldmodel.iconID = groupinfo_en.Result.Icon_id; oldmodel.volume = groupinfo_en.Result.Volume; oldmodel.typeName_en = groupinfo_en.Result.Name; oldmodel.typeName = groupinfo_cn.Result.Name; oldmodel.description = groupinfo_cn.Result.Description; oldmodel.description_en = groupinfo_en.Result.Description; oldmodel.groupID = groupinfo_en.Result.Group_id; oldmodel.attributes.Clear(); if (groupinfo_cn.Result.Dogma_attributes?.Count > 0) { foreach (var resultDogmaAttribute in groupinfo_cn.Result.Dogma_attributes) { newtypeattrs.Add(new type_attributes() { attribute_id = resultDogmaAttribute.Attribute_id, value = resultDogmaAttribute.Value, type_id = i }); } } } catch (Exception e) { await Task.Delay(TimeSpan.FromSeconds(1)); _logger.LogWarning(e + ""); } }, MAX_THREAD); db.evetypes.AddRange(newtypes); await db.SaveChangesAsync(); db.type_attributes.RemoveRange(db.type_attributes); db.AddRange(newtypeattrs); await db.SaveChangesAsync(); var http = _httpClientFactory.CreateClient("CN"); db.InvMetaTypes.RemoveRange(db.InvMetaTypes); await using var bz2file1 = await http.GetStreamAsync("https://www.fuzzwork.co.uk/dump/latest/invMetaTypes.csv.bz2"); await using var fs = new MemoryStream(); BZip2.Decompress(bz2file1, fs, false); fs.Seek(0, SeekOrigin.Begin); using var textreader = new StreamReader(fs); await textreader.ReadLineAsync(); //ignore 1st var r = await textreader.ReadLineAsync(); while (r != null) { var imp = r.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); var newmodel = new invMetaTypes(); newmodel.typeID = int.Parse(imp[0]); if (imp[1] == "None") { newmodel.parentTypeID = null; } else { newmodel.parentTypeID = int.Parse(imp[1]); } if (imp[2] == "None") { newmodel.metaGroupID = null; } else { newmodel.metaGroupID = int.Parse(imp[2]); } db.InvMetaTypes.Add(newmodel); r = await textreader.ReadLineAsync(); //ignore 1st } await db.SaveChangesAsync(); _logger.LogInformation("完成!"); }
public Task <TSource> SingleOrDefaultAsync <TSource>( IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate, CancellationToken token) => EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate, token);
private async Task <int> GetCountAsync(IQueryable newSource) { var results = await GetStaticDataAsync <int>(x => EntityFrameworkQueryableExtensions.CountAsync((dynamic)x), newSource); return(results.Sum()); }