Quick.ElasticSearch.Furion
1.0.3.2
There is a newer version of this package available.
See the version list below for details.
See the version list below for details.
dotnet add package Quick.ElasticSearch.Furion --version 1.0.3.2
NuGet\Install-Package Quick.ElasticSearch.Furion -Version 1.0.3.2
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Quick.ElasticSearch.Furion" Version="1.0.3.2" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Quick.ElasticSearch.Furion --version 1.0.3.2
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: Quick.ElasticSearch.Furion, 1.0.3.2"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Quick.ElasticSearch.Furion as a Cake Addin #addin nuget:?package=Quick.ElasticSearch.Furion&version=1.0.3.2 // Install Quick.ElasticSearch.Furion as a Cake Tool #tool nuget:?package=Quick.ElasticSearch.Furion&version=1.0.3.2
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
1、🍹更新日志
1.0.3.2
- 增加了
CreateEsQueryModelAsync和AddEsQueryModelAsync方法。
- 增加了
1.0.3
调整（简化）了方法
GetModelsAll、GetModelsAllAsync、GetModels、GetModelsAsync、GetModelsFields和GetModelsFieldsAsync的排序参数传入方式；调整了
InsertModels和InsertModelsAsync方法的内部实现，判断是否有添加失败采用了Errors属性以及ItemsWithErrors错误对象集合；增加了
InsertModelsBatch方法，分批添加数据，适用于大批量添加数据的情况；调整了
GetGroupValues、GetGroupValuesAsync、GetGroupCount、GetGroupCountAsync、GetGroupCountSmma、GetGroupCountSmmaAsync、GetGroupsCount、GetGroupsCountAsync、GetGroupsDate、GetGroupsDateAsync、GetGroupsDateSmma、GetGroupsDateSmmaAsync、GetGroupsDateSub、GetGroupsDateSubAsync、GetStatiCount、GetStatiCountAsync、GetStatiSumMulti和GetStatiSumMultiAsync方法的内部实现；调整了
AddLike扩展方式的实现方式为Wildcard；增加了
AddIn条件查询扩展方法，类似SQL的IN条件；对
GetStatiSumMulti和GetStatiSumMultiAsync方法进行了性能优化，减少了Http请求次数。
1.0.2
方法
GetGroupsCount和GetGroupsCountAsync增加了第三个参数，以便于用户自定义返回统计数量的Key名称，默认为：GroupCount；增加了获取
ElasticClient客户端对象方法：GetClient;增加获取所有索引的方法
GetIndexs和GetIndexsAsync；增加了根据主键Id修改一个或多个字段值的方法
UpdateModelFieldsById和UpdateModelFieldsByIdAsync；增加了根据查询条件修改一个或多个字段值的方法
UpdateModelFieldsByCon和UpdateModelFieldsByConAsync；增加了根据Id字段获取一条数据的方法
GetModel和GetModelAsync；调整了
InsertModels和InsertModelsAsync方法的实现，由原来的Bulk（BulkAsync）调整为了IndexMany（IndexManyAsync）方式。
1.0.1
增加了扩展方法CreateEsQueryModel和AddEsQueryModel；
重写了查询条件的使用方式；
将所有涉及到查询条件的方法都进行了调整；
简化了
GetStatiSumMulti和GetStatiSumMultiAsync方法所需参数的传入方式;方法
GetStatiSumMulti和GetStatiSumMultiAsync增加了第三个参数，错误回调方法。
1.0.0
全新组件重磅发布；
支持切换连接功能;
支持检查创建删除索引；
支持获取索引健康状态；
支持添加数据；
支持修改数据；
支持删除数据；
支持获取数据；
支持分组统计查询；
支持获取总条数、最大、最小、求和或平均值等。
2、🍟Quick.ElasticSearch.Furion使用说明
该组件是基于NEST和Furion组件进行封装使用的，目的在于结合.Net Core更快、更简单和更灵活的使用ElasticSearch！！！
组件使用对比：
假设我们要实现如下数据格式的统计：
[
{
"Name":"2021-01",
"Count":100,
"Group":[
{
"Name":"碎石",
"Count":3,
"Sum":1000,
"Max":100,
"Min":10,
"Avg":50
}
]
}
]
使用Quick.ElasticSearch.Furion组件的代码如下：
//获取分组统计数据（日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值）
//统计的时间间隔维度支持的表达式有（1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateSub = _quickElasticSearch.GetGroupsDateSub<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);
//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);
使用NEST组件的代码如下：
/// <summary>
/// 获取分组统计数据（日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="field">要分组的字段（日期字段），格式如：m=>m.CreateTime</param>
/// <param name="fieldGroup">另一个要分组的字段，格式如：m=>m.TypeName</param>
/// <param name="fieldGroupStati">要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price</param>
/// <param name="dateInterval">统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）</param>
/// <param name="dateFormat">统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）</param>
/// <param name="esQueryList">动态查询条件</param>
/// <returns>返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为<![CDATA[List<Dictionary<string, object>>]]>的集合，格式如：[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}]</returns>
public (bool IsSucc, string ErrMsg, List<Dictionary<string, object>>? Data) GetGroupsDateSub<T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) where T : class, new()
{
try
{
//查询条件
Func<QueryContainerDescriptor<T>, QueryContainer> query = q =>
{
QueryContainer ret = q;
if (esQueryList != null && esQueryList.Count > 0)
{
//组装条件为&&或||关系
for (int i = 0; i < esQueryList.Count; i++)
{
if (esQueryList[i].QueryCon.Count > 0)
{
if (i == 0)
{
ret = esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon));
}
else
{
ret = esQueryList[i].PrevConType == EsQueryType.And ?
ret && (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))) ://添加&&并且关系
ret || (esQueryList[i].QueryType == EsQueryType.And ? q.Bool(b => b.Must(esQueryList[i].QueryCon)) : q.Bool(b => b.Should(esQueryList[i].QueryCon))); //添加||或关系
}
}
}
}
return ret;
};
var ret = new List<Dictionary<string, object>>();
var response = _client.Search<T>(s => s
.Index(GetIndexName<T>())
.Query(query)
.Aggregations(ag => ag
.DateHistogram("StatiGroup", dh => dh
.Field(field) //需要聚合分组的字段名称, 类型需要为date, 格式没有要求
.CalendarInterval(dateInterval) //时间间隔，此处设置为1个月（1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）
.TimeZone("+08:00") //设置时区, 这样就相当于东八区的时间
.Format(dateFormat) //返回值格式化，HH大写，不然不能区分上午、下午
.MinimumDocumentCount(0) //为空的话则填充0
.Order(HistogramOrder.KeyAscending) //根据日期字段升序排列
.Aggregations(ag => ag
.Terms("StatiGroup-1", t => t
.Field(fieldGroup)
.Size(_allConfig.MaxQueryCount)
.Order(o => o
.KeyAscending() //按照分组字段升序排序
.CountAscending()//按照统计数量升序排序
)
//统计fieldStati字段的总和、最大值、最小值和平均值
.Aggregations(ags => ags
.Sum("StatiSum", m => m.Field(fieldGroupStati)) //求和
.Max("StatiMax", m => m.Field(fieldGroupStati)) //最大值
.Min("StatiMin", m => m.Field(fieldGroupStati)) //最小值
.Average("StatiAvg", m => m.Field(fieldGroupStati)) //平均值
)
)
)
)
)
.TrackTotalHits(true)//TrackTotalHits必须设置为true，否则返回total总条数超过10000条时总是返回10000
);
if (response.IsValid)
{
//获取分组标识
var stati = response.Aggregations["StatiGroup"];
//获取分组后的集合
var statiItems = ((BucketAggregate)stati).Items;
foreach (var bucketMain in statiItems)
{
var item = (DateHistogramBucket)bucketMain;
var retGroup = new List<Dictionary<string, object>>();
foreach (var bucket in ((Nest.BucketAggregate)(item.Values.ToList()[0])).Items)
{
var obj = (KeyedBucket<Object>)bucket;
retGroup.Add(new Dictionary<string, object> {
{ "Name",obj.Key.ToString()!},
{ "Count",obj.DocCount??0},
{ "Sum",IsNotNull(obj.AverageBucket("StatiSum").Value)? ToDouble2Dec(obj.AverageBucket("StatiSum").Value!):0},
{ "Max",IsNotNull(obj.AverageBucket("StatiMax").Value)? ToDouble2Dec(obj.AverageBucket("StatiMax").Value!):0},
{ "Min",IsNotNull(obj.AverageBucket("StatiMin").Value)? ToDouble2Dec(obj.AverageBucket("StatiMin").Value!):0},
{ "Avg",IsNotNull(obj.AverageBucket("StatiAvg").Value)? ToDouble2Dec(obj.AverageBucket("StatiAvg").Value!):0},
});
}
ret.Add(new Dictionary<string, object>
{
{ "Name",item.KeyAsString},
{ "Count",item.DocCount??0},
{ "Group",retGroup}
});
}
}
return (response.IsValid, !response.IsValid ? response.DebugInformation : string.Empty, ret);
}
catch (Exception ex)
{
return (false, ex.Message, null);
}
}
由此可见，NEST使用的复杂程度，更不用说ElasticSearch.Net了。
功能说明：
根据配置文件读取ElasticSearch连接的各个配置（如：ElasticSearch服务地址、账号和密码等）；
支持配置多个ElasticSearch的连接配置；
支持动态切换ElasticSearch的连接配置；
支持检查创建删除索引；
支持获取索引健康状态；
支持添加数据（单条、多条）；
支持修改数据（单条、多条）；
支持删除数据（根据Id删除、根据条件删除）；
支持获取数据（获取所有数据、获取所有满足条件的数据、获取所有满足条件并返回指定字段的数据、根据Id获取一条数据、获取分页的数据、获取分页并返回指定字段的数据）；
支持分组统计查询（统计单字段并返回该字段所有统计值、统计单字段并返回该字段所有统计值及对应的数量、统计单段并返回另一个字段的总和最大值最小值和平均值、统计多个字段并返回多个字段对应的值以及对应分组的数据数量、按月统计并返回每个月及其数量、获取分组统计数据【日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计】、获取分组统计数据【日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组，按某年1~12月统计每个月的某个字段每个月的总和以及这一年的总和】、获取分组统计数据【日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值】、获取分组统计数据【日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值】）；
支持获取总条数、最大、最小、求和或平均值等（获取符合条件的数据总条数、获取某字段的最大值最小值求和平均值和总数等、获取某些字段相加的多个总和）。
3、🍖安装
安装命令如下所示：
Install-Package Quick.ElasticSearch.Furion
该组件的命名空间为：Quick.ElasticSearch。
4、🧀配置
4.1、🥞配置appsettings.json
在appsettings.json配置文件中创建节点QuickElasticSearch>MaxQueryCount和QuickElasticSearchConfigs，MaxQueryCount为ElasticSearch索引查询的最大条数（ElasticSearch内部默认为10000），QuickElasticSearchConfigs 为数组类型（即可配置多个 ElasticSearch 服务地址），具体配置如下所示：
{
"QuickElasticSearch": {
"MaxQueryCount": 2000000000,
"QuickElasticSearchConfigs": [
{
"Default": true,
"ConnId": 1,
"DefaultIndex": "",
"UserName": "elastic",
"Password": "123456",
"Uri": [ "http://192.168.3.200:9200/" ]
}
]
}
}
配置说明：
| 属性名称 | 属性说明 | 是否必填 | 备注 |
|---|---|---|---|
| MaxQueryCount | 全局设置ElasticSearch索引查询的最大条数，ElasticSearch默认为10000 | 注意：此处我们最好设置为2000000000，原因是ElasticSearch内部默认一次性最多返回10000条数据 | |
| Default | 是否为默认连接 | 默认为false | |
| ConnId | 连接Id（请确保该Id的唯一性） | √ | 如果要动态切换连接配置，请确保该Id有值并且唯一 |
| DefaultIndex | 默认索引 | ||
| UserName | 连接账户 | √ | |
| Password | 连接密码 | √ | |
| Uri | 连接地址集合，数据类型为List<string> | √ |
4.2、🍞实体特性
我们为实体提供了QuickElasticSearchConfig特性，起作用是设置该实体的索引名称和主键字段，如下所示就是我们定义的一个实体对象：
using Nest;
namespace Quick.ElasticSearch.TestFurion
{
[QuickElasticSearchConfig(indexName: "test_index", primaryKey: "Id")]
public class TestElasticSearchModel
{
public long Id { get; set; }
[Keyword]
public string UserType { get; set; }
public int UserId { get; set; }
[Keyword]
public string UserName { get; set; }
public int UserAge { get; set; }
public float Money { get; set; }
public float MoneyOth { get; set; }
public DateTime CreateTime { get; set; }
}
}
说明：
indexName：索引名称；
primaryKey：主键名称。
4.3、🥐配置Program.cs
由于我们使用的是Furion，因此，我们可在程序启动文件中配置如下代码（具体可参考Furion入门指南），目的是注册ElasticSearch服务。
依赖注入方式-WinForm中使用：
Program.cs的Main方法：
[STAThread]
static void Main()
{
ApplicationConfiguration.Initialize();
//初始化Furion
Serve.Run(GenericRunOptions.DefaultSilence);
}
Furion提供的AppStartup启动配置文件：
public void ConfigureServices(IServiceCollection services)
{
//注册FrmMain窗体类
services.AddScoped<FrmMain>();
//注入IQuickElasticSearch的方式
//通过AddElasticSearch添加依赖注入
services.AddElasticSearch();
////使用构造函数获取实例的方式：
////通过AddElasticSearch添加依赖注入，并注册TestConsumerClassForDI类
//services.AddElasticSearch<TestConsumerClassForDI>()
//DI容器生成serviceProvider
var serviceProvider = services.BuildServiceProvider();
//通过serviceProvider获取MainForm的注册实例
var frmMain = serviceProvider.GetRequiredService<FrmMain>();
//var frmMain = (FrmMain)serviceProvider.GetService(typeof(FrmMain));
Application.Run(frmMain);
}
**说明：上述的关键点就在于调用.AddElasticSearch()或者.AddElasticSearch<T>()**方法对服务进行注册。
4.4、🍝获取依赖注入对象
定义IQuickElasticSearch对象（依赖注入方式）：
public partial class FrmMain : Form
{
//定义IQuickElasticSearch对象
private readonly IQuickElasticSearch _quickElasticSearch;
public FrmMain(IQuickElasticSearch quickElasticSearch)
{
InitializeComponent();
//设置IQuickElasticSearch对象
_quickElasticSearch = quickElasticSearch;
}
}
5、🥪具体使用
5.1、📮获取ElasticSearch客户端
使用示例：
_quickElasticSearch.GetClient();
5.2、🌮切换连接
使用示例：
_quickElasticSearch.ChangeConn(2);
5.3、🌯获取检查创建删除索引
使用示例（获取所有索引）：
//同步
var retGetIndexs = _quickElasticSearch.GetIndexs();
//异步
var retGetIndexsAsync = await _quickElasticSearch.GetIndexsAsync();
使用示例（检查索引是否存在）：
//同步
var retIndexIsExist = _quickElasticSearch.IndexIsExist();
//异步
var retIndexIsExistAsync = await _quickElasticSearch.IndexIsExistAsync();
使用示例（创建索引）：
//同步
var retCreateIndex = _quickElasticSearch.CreateIndex<TestElasticSearchModel>();
//异步
var retCreateIndexAsync = await _quickElasticSearch.CreateIndexAsync<TestElasticSearchModel>();
使用示例（删除索引）：
//同步
var retDeleteIndex = _quickElasticSearch.DeleteIndex();
//异步
var retDeleteIndexAsync = await _quickElasticSearch.DeleteIndexAsync();
5.4、🥙获取索引健康状态
使用示例（获取索引健康状态）：
//同步
var retGetHealthStatus = _quickElasticSearch.GetHealthStatus();
//异步
var retGetHealthStatusAsyncc = await _quickElasticSearch.GetHealthStatusAsync();
5.5、🧆添加数据
使用示例（添加数据-单条）：
var rand = new Random(Guid.NewGuid().GetHashCode());
var testData = new TestElasticSearchModel
{
Id = YitIdHelper.NextId(),
UserId = rand.Next(1, 9999),
UserName = "Quber",
UserAge = rand.Next(20, 80),
Money = (float)1.429,
MoneyOth = (float)2.556,
CreateTime = DateTime.Now
};
var testDataAsync = new TestElasticSearchModel
{
Id = YitIdHelper.NextId(),
UserId = rand.Next(1, 9999),
UserName = "Jack",
UserAge = rand.Next(20, 80),
Money = (float)1.429,
MoneyOth = (float)2.556,
CreateTime = DateTime.Now
};
//同步
var retInsertModel = _quickElasticSearch.InsertModel(testData);
//异步
var retInsertModelAsync = await _quickElasticSearch.InsertModelAsync(testDataAsync);
使用示例（添加数据-多条）：
var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel(),
new TestElasticSearchModel()
};
//同步
var retInsertModels = _quickElasticSearch.InsertModels(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
});
//异步
var retInsertModelsAsync = await _quickElasticSearch.InsertModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
await Task.CompletedTask;
});
使用示例（添加数据-多条，分批次）：
var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel(),
new TestElasticSearchModel()
};
var retInsertModelsBatch = _quickElasticSearch.InsertModelsBatch(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
},
//每批次添加的数据条数
1000,
//集群繁忙，报429错误码的时候，等待多久进行重试
"5s",
//重试次数
2);
5.6、🥗修改数据
使用示例（修改数据-根据主键Id修改一个或多个字段的值）：
//类似SQL：UPDATE A SET col1=123,col2=456 WHERE Id=1
//同步
var retUpdateModelFieldById = _quickElasticSearch.UpdateModelFieldsById<TestElasticSearchModel>(342235158519882, new { UserAge = 32, Money = 66.66 });
//异步
var retUpdateModelFieldByIdAsync = await _quickElasticSearch.UpdateModelFieldsByIdAsync<TestElasticSearchModel>(342235158519882, new { UserAge = 32, Money = 66.66 });
使用示例（修改数据-根据查询条件修改一个或多个字段的值）：
//类似SQL：UPDATE A SET col1=123,col2=456 WHERE (Id=1 OR Id=2)
//定义查询条件：(Id = 342235158519882 OR Id = 342235158519883)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,
EsQueryType.Or,
(queryCon) =>
{
//查询条件：(Id = 342235158519882 OR Id = 342235158519883)
queryCon
.AddEqu(m => m.Id, 342235158519882)
.AddEqu(m => m.Id, 342235158519883);
});
//异步
var retUpdateModelFieldsByCon = _quickElasticSearch.UpdateModelFieldsByCon<TestElasticSearchModel>(queryCon, new { UserAge = 13, Money = 996.33 });
//同步
var retUpdateModelFieldsByConAsync = await _quickElasticSearch.UpdateModelFieldsByConAsync<TestElasticSearchModel>(queryCon, new { UserAge = 14, Money = 997.44 });
使用示例（修改数据-单条）：
var rand = new Random(Guid.NewGuid().GetHashCode());
var testData = new TestElasticSearchModel
{
Id = 1,
UserId = rand.Next(1, 9999),
UserName = "Quber1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
};
var testDataAsync = new TestElasticSearchModel
{
Id = 3,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
};
//同步
var retUpdateModel = _quickElasticSearch.UpdateModel(testData);
//异步
var retUpdateModelAsync = await _quickElasticSearch.UpdateModelAsync(testDataAsync);
使用示例（修改数据-多条）：
var rand = new Random(Guid.NewGuid().GetHashCode());
var testDatas = new List<TestElasticSearchModel>
{
new TestElasticSearchModel
{
Id = 1,
UserId = rand.Next(1, 9999),
UserName = "Quber1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
},
new TestElasticSearchModel
{
Id = 3,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
},
new TestElasticSearchModel
{
Id = 4,
UserId = rand.Next(1, 9999),
UserName = "Jack1",
UserAge = rand.Next(20, 80),
Money = (float)2.429,
MoneyOth = (float)3.556,
CreateTime = DateTime.Now
}
};
//同步
var retUpdateModels = _quickElasticSearch.UpdateModels(testDatas, (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
});
//异步
var retUpdateModelsAsync = await _quickElasticSearch.UpdateModelsAsync(testDatas, async (errList, errMsg, allList) =>
{
var thisErrList = errList;
var thisErrMsg = errMsg;
await Task.CompletedTask;
});
5.7、🥘删除数据
使用示例（删除数据-根据Id）：
//同步
var retDeleteModel = _quickElasticSearch.DeleteModel<TestElasticSearchModel>(340504986927178);
//异步
var retDeleteModelAsync = await _quickElasticSearch.DeleteModelAsync<TestElasticSearchModel>(340504986927176);
使用示例（删除数据-根据条件）：
//定义查询条件：(Id >= 340506710462542 AND UserAge <= 60) OR (Id = 340506710462539 OR Id = 340506710462538)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 340506710462542 AND UserAge <= 60)
queryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
})
//添加另一个组合条件
.AddEsQueryModel(
EsQueryType.Or,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.Or,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id = 340506710462539 OR Id = 340506710462538)
queryCon
.AddEqu(m => m.Id, 340506710462539)
.AddEqu(m => m.Id, 340506710462538);
});
//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy<TestElasticSearchModel>(queryCon);
//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync<TestElasticSearchModel>(queryCon);
5.8、🍲获取数据
使用示例（获取所有数据）：
//排序条件：ORDER BY Id DESC
//同步
var retGetModelsAll = _quickElasticSearch.GetModelsAll<TestElasticSearchModel>(m => m.Id, true);
//异步
var retGetModelsAllAsync = await _quickElasticSearch.GetModelsAllAsync<TestElasticSearchModel>(m => m.CreateTime, false);
使用示例（获取匹配条件的所有数据）：
//排序条件：ORDER BY Id DESC
//定义查询条件：(Id >= 340506710462535 AND UserAge <= 70)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
queryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
});
//同步
var retGetModels = _quickElasticSearch.GetModels<TestElasticSearchModel>(m => m.Id, true, queryCon);
//异步
var retGetModelsAsync = await _quickElasticSearch.GetModelsAsync<TestElasticSearchModel>(m => m.Id, true, queryCon);
使用示例（获取匹配条件的所有数据（返回指定字段的值））：
//排序条件：ORDER BY Id DESC
//定义查询条件：(Id >= 340506710462535 AND UserAge <= 70)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
queryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
});
//同步
var retGetModelsFields = _quickElasticSearch.GetModelsFields<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);
//异步
var retGetModelsFieldsAsync = await _quickElasticSearch.GetModelsFieldsAsync<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, m => m.Id, true, queryCon);
使用示例（获取一条数据-根据主键Id查询）：
//同步
var retGetModel = _quickElasticSearch.GetModel<TestElasticSearchModel>(342235158519882);
//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(342235158519883);
使用示例（获取一条数据-根据某字段查询）：
//同步
var retGetModel = _quickElasticSearch.GetModel<TestElasticSearchModel>(m => m.UserId, 340506710462542);
//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(m => m.UserId, 340506710462537);
使用示例（获取分页数据）：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetPager = _quickElasticSearch.GetPager<TestElasticSearchModel>(pagerCon, queryCon);
//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync<TestElasticSearchModel>(pagerCon, queryCon);
使用示例（获取分页数据-返回指定字段的值）：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetPagerFields = _quickElasticSearch.GetPagerFields<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, queryCon);
//异步
var retGetPagerFieldsAsync = await _quickElasticSearch.GetPagerFieldsAsync<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, queryCon);
5.9、🥣分组统计查询
使用示例（单个字段分组，并返回该字段的所有值集合）：
//类似SQL：SELECT col1 FROM A GROUP BY col1
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupValues = _quickElasticSearch.GetGroupValues<TestElasticSearchModel>(m => m.UserName, queryCon);
//异步
var retGetGroupValuesAsync = await _quickElasticSearch.GetGroupValuesAsync<TestElasticSearchModel>(m => m.UserName, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
"Jack1",
"Jack2",
"Jack3"
]
}
使用示例（单个字段分组，并返回该字段的所有值和数量集合）：
//类似SQL：SELECT col1,COUNT(1) FROM A GROUP BY col1
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupCount = _quickElasticSearch.GetGroupCount<TestElasticSearchModel>(m => m.UserName, queryCon);
//异步
var retGetGroupCountAsync = await _quickElasticSearch.GetGroupCountAsync<TestElasticSearchModel>(m => m.UserName, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"Jack1",
"Count":2
},
{
"Name":"Jack2",
"Count":2
},
{
"Name":"Jack3",
"Count":2
}
]
}
使用示例（单个字段分组，并返回另一个字段的总和、最大值、最小值和平均值）：
//类似SQL：SELECT col1,COUNT(1),SUM(col2),MAX(col2),MIN(col2),AVG(col2) FROM A GROUP BY col1
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupCountSmma = _quickElasticSearch.GetGroupCountSmma<TestElasticSearchModel>(m => m.UserName, m => m.UserAge, queryCon);
//异步
var retGetGroupCountSmmaAsync = await _quickElasticSearch.GetGroupCountSmmaAsync<TestElasticSearchModel>(m => m.UserName, m => m.UserAge, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"Jack1",
"Count":2,
"Sum":54,
"Max":31,
"Min":23,
"Avg":27
},
{
"Name":"Jack2",
"Count":2,
"Sum":98,
"Max":77,
"Min":21,
"Avg":49
},
{
"Name":"Jack3",
"Count":2,
"Sum":126,
"Max":67,
"Min":59,
"Avg":63
}
]
}
使用示例（多个字段分组，并返回多个字段对应的值以及对应分组的数据数量）：
//类似SQL：SELECT col1,col2,COUNT(1) FROM A GROUP BY col1,col2
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsCount = _quickElasticSearch.GetGroupsCount<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, queryCon);
//异步
var retGetGroupsCountAsync = await _quickElasticSearch.GetGroupsCountAsync<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"UserName":"Jack1",
"UserAge":23,
"GroupCount":1
},
{
"UserName":"Jack1",
"UserAge":31,
"GroupCount":1
},
{
"UserName":"Jack2",
"UserAge":21,
"GroupCount":1
},
{
"UserName":"Jack2",
"UserAge":77,
"GroupCount":1
},
{
"UserName":"Jack3",
"UserAge":59,
"GroupCount":1
},
{
"UserName":"Jack3",
"UserAge":67,
"GroupCount":1
}
]
}
使用示例（日期字段分组，按月统计）：
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, queryCon);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-08",
"Count":110
},
{
"Name":"2022-09",
"Count":132
},
{
"Name":"2022-10",
"Count":166
}
]
}
使用示例（日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计）：
//统计的时间间隔维度支持的表达式有（1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDate = _quickElasticSearch.GetGroupsDate<TestElasticSearchModel>(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", queryCon);
//异步
var retGetGroupsDateAsync = await _quickElasticSearch.GetGroupsDateAsync<TestElasticSearchModel>(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-10-12 09:24",
"Count":10
},
{
"Name":"2022-10-12 09:25",
"Count":50
},
{
"Name":"2022-10-12 09:26",
"Count":10
},
{
"Name":"2022-10-12 09:27",
"Count":10
},
{
"Name":"2022-10-12 09:28",
"Count":0
},
{
"Name":"2022-10-12 09:29",
"Count":0
},
{
"Name":"2022-10-12 09:30",
"Count":0
},
{
"Name":"2022-10-12 09:31",
"Count":0
},
{
"Name":"2022-10-12 09:32",
"Count":0
},
{
"Name":"2022-10-12 09:33",
"Count":0
},
{
"Name":"2022-10-12 09:34",
"Count":0
},
{
"Name":"2022-10-12 09:35",
"Count":0
},
{
"Name":"2022-10-12 09:36",
"Count":11
},
{
"Name":"2022-10-12 09:37",
"Count":41
}
]
}
使用示例（日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值）：
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonthSmma = _quickElasticSearch.GetGroupsDateMonthSmma<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, queryCon);
//异步
var retGetGroupsDateMonthSmmaAsync = await _quickElasticSearch.GetGroupsDateMonthSmmaAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-10",
"Count":132,
"Sum":6842,
"Max":79,
"Min":21,
"Avg":51.83
}
]
}
使用示例（日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值）：
//统计的时间间隔维度支持的表达式有（1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateSmma = _quickElasticSearch.GetGroupsDateSmma<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", queryCon);
//异步
var retGetGroupsDateSmmaAsync = await _quickElasticSearch.GetGroupsDateSmmaAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-10-12 09:24",
"Count":10,
"Sum":588,
"Max":76,
"Min":31,
"Avg":58.8
},
{
"Name":"2022-10-12 09:25",
"Count":50,
"Sum":2432,
"Max":79,
"Min":21,
"Avg":48.64
},
{
"Name":"2022-10-12 09:26",
"Count":10,
"Sum":512,
"Max":79,
"Min":27,
"Avg":51.2
},
{
"Name":"2022-10-12 09:27",
"Count":10,
"Sum":616,
"Max":76,
"Min":34,
"Avg":61.6
},
{
"Name":"2022-10-12 09:28",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:29",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:30",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:31",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:32",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:33",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:34",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:35",
"Count":0,
"Sum":0,
"Max":0,
"Min":0,
"Avg":0
},
{
"Name":"2022-10-12 09:36",
"Count":11,
"Sum":527,
"Max":74,
"Min":21,
"Avg":47.91
},
{
"Name":"2022-10-12 09:37",
"Count":41,
"Sum":2167,
"Max":78,
"Min":25,
"Avg":52.85
}
]
}
使用示例（日期字段分组，按某年1~12月统计每个月的某个字段每个月的总和以及这一年的总和）：
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonthOneYear = _quickElasticSearch.GetGroupsDateMonthOneYear<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);
//异步
var retGetGroupsDateMonthOneYearAsync = await _quickElasticSearch.GetGroupsDateMonthOneYearAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
[
"Jack1",
0,
0,
0,
0,
0,
0,
0,
0,
0,
54,
0,
0,
54
],
[
"Jack2",
0,
0,
0,
0,
0,
0,
0,
0,
0,
98,
0,
0,
98
],
[
"Jack3",
0,
0,
0,
0,
0,
0,
0,
0,
0,
126,
0,
0,
126
]
]
}
使用示例（日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值）：
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-10",
"Count":132,
"Group":[
{
"Name":"Jack1",
"Count":2,
"Sum":54,
"Max":31,
"Min":23,
"Avg":27
},
{
"Name":"Jack2",
"Count":2,
"Sum":98,
"Max":77,
"Min":21,
"Avg":49
},
{
"Name":"Jack3",
"Count":2,
"Sum":126,
"Max":67,
"Min":59,
"Avg":63
}
]
}
]
}
使用示例（日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值）：
//统计的时间间隔维度支持的表达式有（1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetGroupsDateSub = _quickElasticSearch.GetGroupsDateSub<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);
//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
{
"Name":"2022-10-12 09:00",
"Count":132,
"Group":[
{
"Name":"Jack1",
"Count":2,
"Sum":54,
"Max":31,
"Min":23,
"Avg":27
},
{
"Name":"Jack2",
"Count":2,
"Sum":98,
"Max":77,
"Min":21,
"Avg":49
},
{
"Name":"Jack3",
"Count":2,
"Sum":126,
"Max":67,
"Min":59,
"Avg":63
}
]
}
]
}
5.10、🍝获取总条数、最大、最小、求和或平均值等
使用示例（获取符合条件的数据总条数）：
//类似SQL：SELECT COUNT(1) FROM A
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetCount = _quickElasticSearch.GetCount<TestElasticSearchModel>(queryCon);
//异步
var retGetCountAsync = await _quickElasticSearch.GetCountAsync<TestElasticSearchModel>(queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":132
}
使用示例（获取某字段的最大值、最小值、求和、平均值和总数等）：
//类似SQL：SELECT COUNT(1),SUM(col1),MAX(col1),MIN(col1),AVG(col1) FROM A
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetStatiCount = _quickElasticSearch.GetStatiCount<TestElasticSearchModel>(m => m.UserAge, queryCon);
//异步
var retGetStatiCountAsync = await _quickElasticSearch.GetStatiCountAsync<TestElasticSearchModel>(m => m.UserAge, queryCon);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":{
"Count":132,
"Sum":6842,
"Max":79,
"Min":21,
"Avg":51.83
}
}
使用示例（获取某些字段相加的多个总和）：
//类似SQL：SELECT SUM(col1)分类1,SUM(col2+col3+col4)分类2 FROM A
//统计的字段条件
var fieldCons = new List<EsStatisticalSumMultiModel>()
{
new() { AsName="分类1",Fields=new List<string>{ "Money" } },
new() { AsName="分类2",Fields=new List<string>{ "Money", "MoneyOth" } }
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, queryCon,
(errMsg) =>
{
var thisErrMsg = errMsg;
});
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, queryCon,
async (errMsg) =>
{
var thisErrMsg = errMsg;
await Task.CompletedTask;
});
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":{
"分类1":754.63,
"分类2":1658.02
}
}
6、💎Quick.ElasticSearch.Furion方法
首先通过依赖注入在构造函数中得到IQuickElasticSearch的实例，具体可参照上述文档中的相关示例。
6.1、📔依赖注入方法
| 方法名称 | 方法说明 | 方法参数 | 备注 |
|---|---|---|---|
| AddElasticSearch | 添加依赖注入服务 | 重载1：()<br />重载2：<T>() | 该方法为IServiceCollection的扩展方法，目的是实现IQuickElasticSearch接口的注册。<br />重载1代表注册的是IQuickElasticSearch服务；<br />重载2传入了泛型T，代表的是注册了IQuickElasticSearch服务的同时，也注册了T这个服务（T这个泛型类中，在构造函数中实现了IQuickElasticSearch接口服务，该方法可能在控制台程序使用的情况较多）。 |
| GetInstance | 获取某接口服务的实例 | 重载1：()<br />重载2：() | 该方法为IServiceProvider或IHost的扩展方法，目的是获取某接口或类的实例。<br />重载1是基于IServiceProvider的扩展；<br />重载2是基于IHost的扩展。 |
6.2、💸获取ElasticSearch客户端
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetClient | 获取ElasticSearch客户端 | () | 返回ElasticClient对象 |
6.3、📕切换连接方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| ChangeConn | 切换连接 | (int connId) | 无 | 切换配置文件中某个连接配置，connId为连接Id |
6.4、📗获取检查创建删除索引方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetIndexs | 获取所有索引 | (bool isIncludeSystemIndex = false) | List<CatIndicesRecord> | isIncludeSystemIndex：是否包含系统索引 |
| GetIndexsAsync | 获取所有索引（异步） | (bool isIncludeSystemIndex = false) | List<CatIndicesRecord> | isIncludeSystemIndex：是否包含系统索引 |
| IndexIsExist | 检查索引是否存在 | (string indexName) | 返回bool类型 | indexName：索引名称 |
| IndexIsExistAsync | 检查索引是否存在（异步） | (string indexName) | 返回bool类型 | indexName：索引名称 |
| CreateIndex | 如果同名索引不存在则创建索引 | <T>(int numberOfReplicas = 0, int numberOfShards = 5) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | numberOfReplicas：默认副本数量，如果是单实例，注意改成0<br />numberOfShards：默认分片数量 |
| CreateIndexAsync | 如果同名索引不存在则创建索引（异步） | <T>(int numberOfReplicas = 0, int numberOfShards = 5) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | |
| DeleteIndex | 删除索引 | (string indexName) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | indexName：索引名称 |
| DeleteIndexAsync | 删除索引（异步） | (string indexName) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | indexName：索引名称 |
6.5、📘获取索引健康状态方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetHealthStatus | 获取索引健康状态 | (string indexName) | 返回Health枚举对象（Green：0、Yellow：1、Red：2） | indexName：索引名称 |
| GetHealthStatusAsync | 获取索引健康状态 | (string indexName) | 返回Health枚举对象（Green：0、Yellow：1、Red：2） | indexName：索引名称 |
6.6、📙添加数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| InsertModel | 添加一条数据 | <T>(T docData) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docData：数据<br /> |
| InsertModelAsync | 添加一条数据（异步） | <T>(T docData) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docData：数据<br /> |
| InsertModels | 添加多条数据 | <T>(List<T> docDatas, Action<List<T>, string, List<T>>? insertError = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docDatas：数据<br />insertError：错误回调方法（参数1为出错的数据集合，参数2为出错的提示信息，参数3为修改的所有数据集合） |
| InsertModelsAsync | 添加多条数据（异步） | <T>(List<T> docDatas, Action<List<T>, string, List<T>>? insertError = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docDatas：数据<br />insertError：错误回调方法（参数1为出错的数据集合，参数2为出错的提示信息，参数3为修改的所有数据集合） |
| InsertModelsBatch | 添加多条数据（分批次） | <T>(List<T> docDatas, Action<List<T>, string, List<T>>? insertError = null, int? batchCount = 1000, string backOffTime = "30s", int? backOffRetries = 5) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docDatas：数据<br />insertError：错误回调方法（参数1为出错的数据集合，参数2为出错的提示信息，参数3为修改的所有数据集合）<br />batchCount：每批次添加的数据条数<br />backOffTime：集群繁忙，报429错误码的时候，等待多久进行重试，默认为：30s<br />backOffRetries：重试次数，默认为：5次 |
6.7、📚修改数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| UpdateModelFieldsById | 根据主键Id修改一个或多个字段的值 | <T>(object id, object updateObj) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />id：主键Id值<br />updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的 |
| UpdateModelFieldsByIdAsync | 根据主键Id修改一个或多个字段的值（异步） | <T>(object id, object updateObj) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />id：主键Id值<br />updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的 |
| UpdateModelFieldsByCon | 根据查询条件修改一个或多个字段的值 | <T>(List<EsQueryModel<T>> esQueryList, object updateObj) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />esQueryList：动态查询条件<br />updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的 |
| UpdateModelFieldsByConAsync | 根据查询条件修改一个或多个字段的值（异步） | <T>(List<EsQueryModel<T>> esQueryList, object updateObj) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />esQueryList：动态查询条件<br />updateObj：修改的动态对象，格式如：new { col1 = 123, col2 = 456}，需要注意的是，填写的字段一定要和实体一致，如果修改的字段在数据中不存在，会自动增加这个字段的 |
| UpdateModel | 修改一条数据 | <T>(T docData) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docData：数据<br /> |
| UpdateModelAsync | 修改一条数据（异步） | <T>(T docData) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docData：数据<br /> |
| UpdateModels | 修改多条数据 | <T>(List<T> docDatas, Action<List<T>, string, List<T>>? updateError = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docDatas：数据<br />updateError：错误回调方法（参数1为出错的数据集合，参数2为出错的提示信息，参数3为修改的所有数据集合） |
| UpdateModelsAsync | 修改多条数据（异步） | <T>(List<T> docDatas, Action<List<T>, string, List<T>>? updateError = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />docDatas：数据<br />updateError：错误回调方法（参数1为出错的数据集合，参数2为出错的提示信息，参数3为修改的所有数据集合） |
6.8、📓删除数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| DeleteModel | 删除数据（根据Id字段） | <T>(object dataId) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />dataId：要删除的数据ID<br /> |
| DeleteModelAsync | 删除数据（根据Id字段，异步） | <T>(object dataId) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />dataId：要删除的数据ID<br /> |
| DeleteModelBy | 删除符合条件的所有数据 | <T>(List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | params：动态查询条件 |
| DeleteModelByAsync | 删除符合条件的所有数据（异步） | <T>(List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | params：动态查询条件 |
6.9、📒获取数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetModelsAll | 获取所有数据 | <T>(Expression<Func<T, object>>? field = null, bool isDesc = true) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序） |
| GetModelsAllAsync | 获取所有数据（异步） | <T>(Expression<Func<T, object>>? field = null, bool isDesc = true) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序） |
| GetModels | 获取匹配条件的所有数据 | <T>(Expression<Func<T, object>>? field = null, bool isDesc = true, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序）<br />esQueryList：动态查询条件 |
| GetModelsAsync | 获取匹配条件的所有数据（异步） | <T>(Expression<Func<T, object>>? field = null, bool isDesc = true, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序）<br />esQueryList：动态查询条件 |
| GetModelsFields | 获取匹配条件的所有数据（返回指定字段的值） | <T>(List<string> speFields, Expression<Func<T, object>>? field = null, bool isDesc = true, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合 | T：泛型对象<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序）<br />esQueryList：动态查询条件 |
| GetModelsFieldsAsync | 获取匹配条件的所有数据（返回指定字段的值，异步） | <T>(List<string> speFields, Expression<Func<T, object>>? field = null, bool isDesc = true, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合 | T：泛型对象<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />field：排序字段，格式如：m ⇒ m.OptTime<br />isDesc：是否为降序（默认为降序）<br />esQueryList：动态查询条件 |
| GetModel | 获取一条数据（根据某字段执行等于查询） | <T>(Expression<Func<T, object>> field, object fieldVal) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为T的数据对象 | T：泛型对象<br />field：查询的字段<br />fieldVal：查询的字段对应的值 |
| GetModelAsync | 获取一条数据（根据某字段执行等于查询，异步） | <T>(Expression<Func<T, object>> field, object fieldVal) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为T的数据对象 | T：泛型对象<br />field：查询的字段<br />fieldVal：查询的字段对应的值 |
| GetPagerAsync | 获取分页数据 | <T>(EsPagerConModel esPagerCon, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerModel<T>的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />esQueryList：动态查询条件 |
| GetPagerAsync | 获取分页数据（异步） | <T>(EsPagerConModel esPagerCon, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerModel<T>的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />esQueryList：动态查询条件 |
| GetPagerFields | 获取分页数据（返回指定字段的值） | <T>(EsPagerConModel esPagerCon, List<string> speFields, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerDicModel的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />esQueryList：动态查询条件 |
| GetPagerFieldsAsync | 获取分页数据（返回指定字段的值，异步） | <T>(EsPagerConModel esPagerCon, List<string> speFields, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerDicModel的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />esQueryList：动态查询条件 |
6.10、📋分组统计查询方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetGroupValues | 单个字段分组，并返回该字段的所有值集合 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<string>的集合，格式如：["分类1","分类2"] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupValuesAsync | 单个字段分组，并返回该字段的所有值集合，异步 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<string>的集合，格式如：["分类1","分类2"] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupCount | 单个字段分组，并返回该字段的所有值和数量集合 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类1","Count":100}] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupCountAsync | 单个字段分组，并返回该字段的所有值和数量集合，异步 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类1","Count":100}] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupCountSmma | 单个字段分组，并返回另一个字段的总和、最大值、最小值和平均值 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />fieldStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.col2<br />esQueryList：动态查询条件 |
| GetGroupCountSmmaAsync | 单个字段分组，并返回另一个字段的总和、最大值、最小值和平均值，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类1","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />fieldStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.col2<br />esQueryList：动态查询条件 |
| GetGroupsCount | 多个字段分组 | <T>(List<string> groupFields, List<EsQueryModel<T>>? esQueryList = null, string countKeyName = "GroupCount") | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}] | T：泛型对象<br />groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" }<br />esQueryList：动态查询条件<br />countKeyName：返回统计数量的Key名称，默认为：GroupCount |
| GetGroupsCountAsync | 多个字段分组，异步 | <T>(List<string> groupFields, List<EsQueryModel<T>>? esQueryList = null, string countKeyName = "GroupCount") | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}] | T：泛型对象<br />groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" }<br />esQueryList：动态查询条件<br />countKeyName：返回统计数量的Key名称，默认为：GroupCount |
| GetGroupsDateMonth | 日期字段分组，按月统计 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthAsync | 日期字段分组，按月统计，异步 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />esQueryList：动态查询条件 |
| GetGroupsDate | 日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计 | <T>(Expression<Func<T, object>> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
| GetGroupsDateAsync | 日期字段分组，支持按年、季度、月份、星期、天、小时、分、秒等维度进行统计，异步 | <T>(Expression<Func<T, object>> field, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthSmma | 日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthSmmaAsync | 日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />esQueryList：动态查询条件 |
| GetGroupsDateSmma | 日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
| GetGroupsDateSmmaAsync | 日期字段分组，并返回另一个字段的总和、最大值、最小值和平均值，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Sum":999,"Max":200,"Min":10,"Avg":105}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthOneYear | 日期字段分组，按某年1~12月统计每个月的某个字段每个月的总和以及这一年的总和 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, int year, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为分组统计数组，格式如：[["小米",3006,0,0,0,1100,0,0,0,1200,0,0,0,5306]]，其中第一个值为fieldGroup的分组名称；后面第二个到第十三个值为1~12月份的总和；第十四个值为1~12月份的总和 | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />year：统计的年份，如2021<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthOneYearAsync | 日期字段分组，按某年1~12月统计每个月的某个字段每个月的总和以及这一年的总和，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, int year, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为分组统计数组，格式如：[["小米",3006,0,0,0,1100,0,0,0,1200,0,0,0,5306]]，其中第一个值为fieldGroup的分组名称；后面第二个到第十三个值为1~12月份的总和；第十四个值为1~12月份的总和 | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />year：统计的年份，如2021<br />esQueryList：动态查询条件 |
| GetGroupsDateMonth | 日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />esQueryList：动态查询条件 |
| GetGroupsDateMonthAsync | 日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />esQueryList：动态查询条件 |
| GetGroupsDateSub | 日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
| GetGroupsDateSubAsync | 日期字段分组，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值，异步 | <T>(Expression<Func<T, object>> field, Expression<Func<T, object>> fieldGroup, Expression<Func<T, object>> fieldGroupStati, string dateInterval = "1M", string dateFormat = "yyyy-MM", List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"2021-01","Count":100,"Group":[{"Name":"碎石","Count":3,"Sum":1000,"Max":100,"Min":10,"Avg":50}]}] | T：泛型对象<br />field：要分组的字段（日期字段），格式如：m=>m.CreateTime<br />fieldGroup：另一个要分组的字段，格式如：m=>m.TypeName<br />fieldGroupStati：要统计总和、最大值、最小值和平均值的字段，格式如：m=>m.Price<br />dateInterval：统计的日期间隔，默认为1M（支持的表达式有1y：1年、1q：1季度、1M：1个月、1w：1星期、1d：1天、1h：1小时、1m：1分钟、1s：1秒钟）<br />dateFormat：统计的日期格式化方式，默认为yyyy-MM（注意大小写，完整的格式化格式为yyyy-MM-dd HH:mm:ss）<br />esQueryList：动态查询条件 |
6.11、📜获取总条数、最大、最小、求和或平均值等方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetCount | 获取符合条件的数据总条数 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数 | T：泛型对象<br />esQueryList：动态查询条件 |
| GetCountAsync | 获取符合条件的数据总条数（异步） | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数 | T：泛型对象<br />esQueryList：动态查询条件 |
| GetStatiCount | 获取某字段的最大值、最小值、求和、平均值和总数等 | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200} | T：泛型对象<br />field：要求和、最大值、最小值和平均值的字段B，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetStatiCountAsync | 获取某字段的最大值、最小值、求和、平均值和总数等（异步） | <T>(Expression<Func<T, object>> field, List<EsQueryModel<T>>? esQueryList = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200} | T：泛型对象<br />field：要求和、最大值、最小值和平均值的字段B，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetStatiSumMulti | 获取某些字段相加的多个总和 | <T>(List<EsStatisticalSumMultiModel> fieldCons, bool is2Dec, List<EsQueryModel<T>>? esQueryList = null, Action<string>? error = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类1":100,"分类2":200} | T：泛型对象<br />fieldCons：统计的某些字段多个总和的条件集合<br />is2Dec：是否将总和结果保留2为小数，false则将保持原小数返回<br />esQueryList：动态查询条件<br />error：错误回调方法（参数1为出错的提示信息） |
| GetStatiSumMultiAsync | 获取某些字段相加的多个总和（异步） | <T>(List<EsStatisticalSumMultiModel> fieldCons, bool is2Dec, List<EsQueryModel<T>>? esQueryList = null, Func<string, Task>? error = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类1":100,"分类2":200} | T：泛型对象<br />fieldCons：统计的某些字段多个总和的条件集合<br />is2Dec：是否将总和结果保留2为小数，false则将保持原小数返回<br />esQueryList：动态查询条件<br />error：错误回调方法（参数1为出错的提示信息） |
6.12、💰查询条件
在上面的方法中，基本都涉及到了关于查询条件（List<EsQueryModel<T>>? esQueryList = null）的参数，在此专门对查询条件的使用进行说明。
创建查询条件：
我们使用QuickElasticSearchExtension.CreateEsQueryModel<T>静态方法来创建一个查询条件集合对象，如下所示：
//创建查询条件集合对象
//CreateEsQueryModel方法需要传入泛型T，第一个参数代表和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）、第二个参数代表当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）、第三个参数代表当前组合查询条件的回调函数，用于添加具体条件
//下述代表的是创建了一个查询条件集合对象queryCon，并且设置了该对象第一个集合中的2个查询条件，类似SQL：(Id >= 340506710462542 AND UserAge <= 60)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 340506710462542 AND UserAge <= 60)
queryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
});
组合条件：
上述的例子，我们只声明了一个组合条件，如果需要多个组合条件一起使用，则直接调用AddEsQueryModel方法继续添加组合条件即可（该方法为上述创建的条件集合对象queryCon的扩展方法【链式操作】），该方法的参数和CreateEsQueryModel一模一样，如下所示的代码代表(Id 大于或等于 340506710462542 并且 UserAge 小于或等于 60) 或者(Id 等于 340506710462539 或者 Id 等于 340506710462538)：
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 340506710462542 AND UserAge <= 60)
queryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
})
//添加另一个组合条件
.AddEsQueryModel(
EsQueryType.Or,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.Or,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id = 340506710462539 OR Id = 340506710462538)
queryCon
.AddEqu(m => m.Id, 340506710462539)
.AddEqu(m => m.Id, 340506710462538);
});
//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy<TestElasticSearchModel>(queryCon);
//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync<TestElasticSearchModel>(queryCon);
更多条件：
如果我们想添加更多条件，直接使用方法AddEsQueryModel追加即可，如下所示：
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(……,……,……)
//第二个组合条件
.AddEsQueryModel(……,……,……)
//第三个组合条件
.AddEsQueryModel(……,……,……)
//第四个组合条件
.AddEsQueryModel(……,……,……)
//第五个组合条件
.AddEsQueryModel(……,……,……)
//第n个组合条件
.……;
EsQueryModel说明：
- PrevConType：和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）；
- QueryType：查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）；
- QueryCon：查询条件集合。
查询条件扩展方法：
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| CreateEsQueryModel | 创建查询条件集合对象 | (EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action<List<Func<QueryContainerDescriptor<T>, QueryContainer>>>? queryConAction = null) | List<EsQueryModel<T>> | T：泛型对象<br />prevConType：和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）<br />queryType：当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）<br />queryConAction：当前组合查询条件的回调函数，用于添加具体条件 |
| AddEsQueryModel | 添加查询条件 | <T>(this List<EsQueryModel<T>> queryModels, EsQueryType prevConType = EsQueryType.And, EsQueryType queryType = EsQueryType.And, Action<List<Func<QueryContainerDescriptor<T>, QueryContainer>>>? queryConAction = null) | List<EsQueryModel<T>> | T：泛型对象<br />prevConType：和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）<br />queryType：当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）<br />queryConAction：当前组合查询条件的回调函数，用于添加具体条件 |
| GetSort | 获取排序条件 | <T>(string field, bool isDesc = true) | Func<SortDescriptor<T>, SortDescriptor<T>> | T：泛型对象<br />field：排序字段<br />isDesc：是否为降序（默认为降序） |
| GetSort | 获取排序条件 | <T>(string field, bool isDesc = true) | Func<SortDescriptor<T>, SortDescriptor<T>> | T：泛型对象<br />field：排序字段<br />isDesc：是否为降序（默认为降序） |
| CreateAndOrs | 创建AND或OR条件集合 | <T>() | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br /><br />使用示例：var queryCon = QuickElasticSearchExtension.CreateAndOrs<T>(); |
| AddEqu | 添加等于查询条件= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, object value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddEqu(m ⇒ m.Id, "7"); |
| AddIn | 添加IN查询条件 | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, List<object> values) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />values：查询的具体值<br /><br />使用示例：queryCon.AddNotEqu(m ⇒ m.Id, new List<object>{"7","21","28"}); |
| AddNotEqu | 添加不等于查询条件!= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, object value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddNotEqu(m ⇒ m.Id, "7"); |
| AddNotEqu | 添加不等于查询条件!= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, List<object> values) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />values：查询的具体值<br /><br />使用示例：queryCon.AddNotEqu(m ⇒ m.Id, new List<object>{"7","21","28"}); |
| AddLike | 添加模糊查询条件LIKE | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> fields, string value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />fields：字段表达式，如：m ⇒ m.Id 或 m=>new [] {m.EngPart, m.TestType}<br />value：查询的关键字<br /><br />使用示例：queryCon.AddLike(m ⇒ m.EngPart, "测试的关键字"); |
| AddGt | 添加大于查询条件> | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddGt(m ⇒ m.Id, 28); |
| AddGt | 添加大于查询条件> | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.CreateTime<br />value：查询的具体值<br /><br />使用示例：queryCon.AddGt(m ⇒ m.CreateTime, "2022-10-12 14:10:26"); |
| AddGte | 添加大于或等于查询条件>= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddGte(m ⇒ m.Id, 28); |
| AddGte | 添加大于或等于查询条件>= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.CreateTime<br />value：查询的具体值<br /><br />使用示例：queryCon.AddGte(m ⇒ m.CreateTime, "2022-10-12 14:10:26"); |
| AddLt | 添加小于查询条件< | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddLt(m ⇒ m.Id, 28); |
| AddLt | 添加小于查询条件< | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.CreateTime<br />value：查询的具体值<br /><br />使用示例：queryCon.AddLt(m ⇒ m.CreateTime, "2022-10-12 14:10:26"); |
| AddLte | 添加小于或等于查询条件<= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, double value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.Id<br />value：查询的具体值<br /><br />使用示例：queryCon.AddLte(m ⇒ m.Id, 28); |
| AddLte | 添加小于或等于查询条件<= | <T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> andOrCons, Expression<Func<T, object>> field, DateTime value) | List<Func<QueryContainerDescriptor<T>, QueryContainer>> | T：泛型对象<br />field：字段表达式，如：m ⇒ m.CreateTime<br />value：查询的具体值<br /><br />使用示例：queryCon.AddLte(m ⇒ m.CreateTime, "2022-10-12 14:10:26"); |
分页查询条件：
我们在使用分页方法的时候，第一个参数需要传入分页查询参数EsPagerConModel，如下所示：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetPager = _quickElasticSearch.GetPager<TestElasticSearchModel>(pagerCon, queryCon);
//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync<TestElasticSearchModel>(pagerCon, queryCon);
EsPagerConModel说明：
- PageIndex：当前页码（默认为1）；
- PageSize：当前页数量（默认为15）；
- OrderField：排序字段；
- OrderType：排序方式（默认为desc）。
统计查询条件：
我们在使用GetStatiSumMulti或GetStatiSumMultiAsync方法获取某些字段相加的多个总和的统计的时候，第一个参数需要传入EsStatisticalSumMultiModel，如下所示：
//类似SQL：SELECT SUM(col1)分类1,SUM(col2+col3+col4)分类2 FROM A
//统计的字段条件
var fieldCons = new List<EsStatisticalSumMultiModel>()
{
new() { AsName="分类1",Fields=new List<string>{ "Money" } },
new() { AsName="分类2",Fields=new List<string>{ "Money", "MoneyOth" } }
};
//定义查询条件：(Id >= 1)
var queryCon = QuickElasticSearchExtension
//创建条件（默认创建了一个组合条件）
.CreateEsQueryModel<TestElasticSearchModel>(
EsQueryType.And,//和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）
EsQueryType.And,//当前组合查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）
(queryCon) =>
{
//查询条件：(Id >= 1)
queryCon.AddGte(m => m.Id, 1);
});
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, queryCon,
(errMsg) =>
{
var thisErrMsg = errMsg;
});
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, queryCon,
async (errMsg) =>
{
var thisErrMsg = errMsg;
await Task.CompletedTask;
});
EsStatisticalSumMultiModel说明：
- AsName（string）：某几个字段相加总和最后返回的Key名称；
- Fields（List<string>）：某几个字段相加的字段集合。
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net6.0 is compatible. net6.0-android was computed. net6.0-ios was computed. net6.0-maccatalyst was computed. net6.0-macos was computed. net6.0-tvos was computed. net6.0-windows was computed. net7.0 was computed. net7.0-android was computed. net7.0-ios was computed. net7.0-maccatalyst was computed. net7.0-macos was computed. net7.0-tvos was computed. net7.0-windows was computed. net8.0 was computed. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. |
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.