Quick.ElasticSearch.Furion
1.0.0
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.0
NuGet\Install-Package Quick.ElasticSearch.Furion -Version 1.0.0
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.0" />
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.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: Quick.ElasticSearch.Furion, 1.0.0"
#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.0 // Install Quick.ElasticSearch.Furion as a Cake Tool #tool nuget:?package=Quick.ElasticSearch.Furion&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
1、🍹更新日志
- 1.0.0
全新组件重磅发布；
支持切换连接功能;
支持检查创建删除索引；
支持获取索引健康状态；
支持添加数据；
支持修改数据；
支持删除数据；
支持获取数据；
支持分组统计查询；
支持获取总条数、最大、最小、求和或平均值等。
2、🍟Quick.ElasticSearch.Furion使用说明
该组件是基于NEST和Furion组件进行封装使用的，目的在于结合.Net Core更快、更简单和更灵活的使用ElasticSearch！！！
功能说明：
根据配置文件读取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; }
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、🍝获取依赖注入对象
定义发送对象（依赖注入方式）：
public partial class FrmMain : Form
{
private readonly IQuickElasticSearch _quickElasticSearch;
public FrmMain(IQuickElasticSearch quickElasticSearch)
{
InitializeComponent();
//定义发送对象
_quickElasticSearch = quickElasticSearch;
}
}
5、🥪具体使用
5.1、🌮切换连接
使用示例：
_quickElasticSearch.ChangeConn(2);
5.2、🌯检查创建删除索引
使用示例（检查索引是否存在）：
//同步
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.3、🥙获取索引健康状态
使用示例（获取索引健康状态）：
//同步
var retGetHealthStatus = _quickElasticSearch.GetHealthStatus();
//异步
var retGetHealthStatusAsyncc = await _quickElasticSearch.GetHealthStatusAsync();
5.4、🧆添加数据
使用示例（添加数据-单条）：
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;
});
5.5、🥗修改数据
使用示例（修改数据-单条）：
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.6、🥘删除数据
使用示例（删除数据-根据Id）：
//同步
var retDeleteModel = _quickElasticSearch.DeleteModel<TestElasticSearchModel>(340504986927178);
//异步
var retDeleteModelAsync = await _quickElasticSearch.DeleteModelAsync<TestElasticSearchModel>(340504986927176);
使用示例（删除数据-根据条件）：
var andCons1 = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
var andCons2 = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.Or,
QueryType = EsQueryType.Or
};
//查询条件：(Id >= 340506710462542 AND UserAge <= 60) OR (Id = 340506710462539 OR Id = 340506710462538)
andCons1.QueryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
andCons2.QueryCon
.AddEqu(m => m.Id, 340506710462539)
.AddEqu(m => m.Id, 340506710462538);
//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy<TestElasticSearchModel>(andCons1, andCons2);
//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync<TestElasticSearchModel>(andCons1, andCons2);
5.7、🍲获取数据
使用示例（获取所有数据）：
//排序条件：ORDER BY Id DESC
var sortCon1 = QuickElasticSearchExtension.GetSort<TestElasticSearchModel>(m => m.Id, true);
//排序条件：ORDER BY CreateTime ASC
var sortCon2 = QuickElasticSearchExtension.GetSort<TestElasticSearchModel>(m => m.CreateTime, false);
//同步
var retGetModelsAll = _quickElasticSearch.GetModelsAll<TestElasticSearchModel>(sortCon1);
//异步
var retGetModelsAllAsync = await _quickElasticSearch.GetModelsAllAsync<TestElasticSearchModel>(sortCon2);
使用示例（获取匹配条件的所有数据）：
//排序条件：ORDER BY Id DESC
var sortCon = QuickElasticSearchExtension.GetSort<TestElasticSearchModel>(m => m.Id, true);
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
andCons.QueryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
//同步
var retGetModels = _quickElasticSearch.GetModels<TestElasticSearchModel>(sortCon, andCons);
//异步
var retGetModelsAsync = await _quickElasticSearch.GetModelsAsync<TestElasticSearchModel>(sortCon, andCons);
使用示例（获取匹配条件的所有数据（返回指定字段的值））：
var sortCon = QuickElasticSearchExtension.GetSort<TestElasticSearchModel>(m => m.Id, true);
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 340506710462535 AND UserAge <= 70)
andCons.QueryCon
.AddGte(m => m.Id, 340506710462535)
.AddLte(m => m.UserAge, 70);
//同步
var retGetModelsFields = _quickElasticSearch.GetModelsFields<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, sortCon, andCons);
//异步
var retGetModelsFieldsAsync = await _quickElasticSearch.GetModelsFieldsAsync<TestElasticSearchModel>(new List<string> { "UserId", "UserName", "UserAge" }, sortCon, andCons);
使用示例（获取一条数据-根据Id查询）：
//同步
var retGetModel = _quickElasticSearch.GetModel<TestElasticSearchModel>(m => m.Id, 340506710462542);
//异步
var retGetModelAsync = await _quickElasticSearch.GetModelAsync<TestElasticSearchModel>(m => m.Id, 340506710462537);
使用示例（获取分页数据）：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetPager = _quickElasticSearch.GetPager<TestElasticSearchModel>(pagerCon, andCons);
//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync<TestElasticSearchModel>(pagerCon, andCons);
使用示例（获取分页数据-返回指定字段的值）：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetPagerFields = _quickElasticSearch.GetPagerFields<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, andCons);
//异步
var retGetPagerFieldsAsync = await _quickElasticSearch.GetPagerFieldsAsync<TestElasticSearchModel>(pagerCon, new List<string> { "UserId", "UserName", "UserAge" }, andCons);
5.8、🥣分组统计查询
使用示例（单个字段分组，并返回该字段的所有值集合）：
//类似SQL：SELECT col1 FROM A GROUP BY col1
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupValues = _quickElasticSearch.GetGroupValues<TestElasticSearchModel>(m => m.UserName, andCons);
//异步
var retGetGroupValuesAsync = await _quickElasticSearch.GetGroupValuesAsync<TestElasticSearchModel>(m => m.UserName, andCons);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":[
"Jack1",
"Jack2",
"Jack3"
]
}
使用示例（单个字段分组，并返回该字段的所有值和数量集合）：
//类似SQL：SELECT col1,COUNT(1) FROM A GROUP BY col1
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupCount = _quickElasticSearch.GetGroupCount<TestElasticSearchModel>(m => m.UserName, andCons);
//异步
var retGetGroupCountAsync = await _quickElasticSearch.GetGroupCountAsync<TestElasticSearchModel>(m => m.UserName, andCons);
统计结果示例：
{
"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
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupCountSmma = _quickElasticSearch.GetGroupCountSmma<TestElasticSearchModel>(m => m.UserName, m => m.UserAge, andCons);
//异步
var retGetGroupCountSmmaAsync = await _quickElasticSearch.GetGroupCountSmmaAsync<TestElasticSearchModel>(m => m.UserName, m => m.UserAge, andCons);
统计结果示例：
{
"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
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsCount = _quickElasticSearch.GetGroupsCount<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, andCons);
//异步
var retGetGroupsCountAsync = await _quickElasticSearch.GetGroupsCountAsync<TestElasticSearchModel>(new List<string> { "UserName", "UserAge" }, andCons);
统计结果示例：
{
"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
}
]
}
使用示例（日期字段分组，按月统计）：
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, andCons);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, andCons);
统计结果示例：
{
"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秒钟）
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDate = _quickElasticSearch.GetGroupsDate<TestElasticSearchModel>(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", andCons);
//异步
var retGetGroupsDateAsync = await _quickElasticSearch.GetGroupsDateAsync<TestElasticSearchModel>(m => m.CreateTime, "1m", "yyyy-MM-dd HH:mm", andCons);
统计结果示例：
{
"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
}
]
}
使用示例（日期字段分组，按月统计，并返回另一个字段的总和、最大值、最小值和平均值）：
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDateMonthSmma = _quickElasticSearch.GetGroupsDateMonthSmma<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, andCons);
//异步
var retGetGroupsDateMonthSmmaAsync = await _quickElasticSearch.GetGroupsDateMonthSmmaAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, andCons);
统计结果示例：
{
"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秒钟）
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDateSmma = _quickElasticSearch.GetGroupsDateSmma<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", andCons);
//异步
var retGetGroupsDateSmmaAsync = await _quickElasticSearch.GetGroupsDateSmmaAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserAge, "1m", "yyyy-MM-dd HH:mm", andCons);
统计结果示例：
{
"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月统计每个月的某个字段每个月的总和以及这一年的总和）：
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDateMonthOneYear = _quickElasticSearch.GetGroupsDateMonthOneYear<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, andCons);
//异步
var retGetGroupsDateMonthOneYearAsync = await _quickElasticSearch.GetGroupsDateMonthOneYearAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, 2022, andCons);
统计结果示例：
{
"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
]
]
}
使用示例（日期字段分组，按月统计，并按照另一个字段进行分组，统计其条数、总和、最大值、最小值和平均值）：
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetGroupsDateMonth = _quickElasticSearch.GetGroupsDateMonth<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, andCons);
//异步
var retGetGroupsDateMonthAsync = await _quickElasticSearch.GetGroupsDateMonthAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, andCons);
统计结果示例：
{
"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秒钟）
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.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", andCons);
//异步
var retGetGroupsDateSubAsync = await _quickElasticSearch.GetGroupsDateSubAsync<TestElasticSearchModel>(m => m.CreateTime, m => m.UserName, m => m.UserAge, "1h", "yyyy-MM-dd HH:mm", andCons);
统计结果示例：
{
"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.9、🍝获取总条数、最大、最小、求和或平均值等
使用示例（获取符合条件的数据总条数）：
//类似SQL：SELECT COUNT(1) FROM A
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetCount = _quickElasticSearch.GetCount<TestElasticSearchModel>(andCons);
//异步
var retGetCountAsync = await _quickElasticSearch.GetCountAsync<TestElasticSearchModel>(andCons);
统计结果示例：
{
"Item1":true,
"Item2":"",
"Item3":132
}
使用示例（获取某字段的最大值、最小值、求和、平均值和总数等）：
//类似SQL：SELECT COUNT(1),SUM(col2),MAX(col2),MIN(col2),AVG(col2) FROM A GROUP BY col1
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetStatiCount = _quickElasticSearch.GetStatiCount<TestElasticSearchModel>(m => m.UserAge, andCons);
//异步
var retGetStatiCountAsync = await _quickElasticSearch.GetStatiCountAsync<TestElasticSearchModel>(m => m.UserAge, andCons);
统计结果示例：
{
"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<TestElasticSearchModel>>()
{
new() { AsName="分类1",Fields=new List<Expression<Func<TestElasticSearchModel, object>>>{ m=>m.Money } },
new() { AsName="分类2",Fields=new List<Expression<Func<TestElasticSearchModel, object>>>{ m => m.Money, m => m.MoneyOth } }
};
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, andCons);
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, andCons);
统计结果示例：
{
"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、📕切换连接方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| ChangeConn | 切换连接 | (int connId) | 无 | 切换配置文件中某个连接配置，connId为连接Id |
6.3、📗检查创建删除索引方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| 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.4、📘获取索引健康状态方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetHealthStatus | 获取索引健康状态 | (string indexName) | 返回Health枚举对象（Green：0、Yellow：1、Red：2） | indexName为索引名称 |
| GetHealthStatusAsync | 获取索引健康状态 | (string indexName) | 返回Health枚举对象（Green：0、Yellow：1、Red：2） | indexName为索引名称 |
6.5、📙添加数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| 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为修改的所有数据集合） |
6.6、📚修改数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| 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.7、📓删除数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| DeleteModel | 删除数据 | <T>(object dataId) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />dataId：要删除的数据ID<br /> |
| DeleteModelAsync | 删除数据（异步） | <T>(object dataId) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | T：泛型对象<br />dataId：要删除的数据ID<br /> |
| DeleteModelBy | 删除符合条件的所有数据 | <T>(params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | params：动态查询条件 |
| DeleteModelByAsync | 删除符合条件的所有数据（异步） | <T>(params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含2个值，第一个为是否成功，第二个为失败的提示信息 | params：动态查询条件 |
6.8、📒获取数据方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetModelsAll | 获取所有数据 | <T>(Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true) |
| GetModelsAllAsync | 获取所有数据（异步） | <T>(Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true) |
| GetModels | 获取匹配条件的所有数据 | <T>(Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true)<br />esQueryList：动态查询条件 |
| GetModelsAsync | 获取匹配条件的所有数据（异步） | <T>(Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<T>的集合 | T：泛型对象<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true)<br />esQueryList：动态查询条件 |
| GetModelsFields | 获取匹配条件的所有数据（返回指定字段的值） | <T>(List<string> speFields, Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合 | T：泛型对象<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true)<br />esQueryList：动态查询条件 |
| GetModelsFieldsAsync | 获取匹配条件的所有数据（返回指定字段的值，异步） | <T>(List<string> speFields, Func<SortDescriptor<T>, SortDescriptor<T>>? sortCon = null, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合 | T：泛型对象<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />sortCon：排序表达式，如：QuickElasticSearchExtension.GetSort<SYS_LogInfo>(m ⇒ m.OptTime, true)<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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerModel<T>的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />esQueryList：动态查询条件 |
| GetPagerAsync | 获取分页数据（异步） | <T>(EsPagerConModel esPagerCon, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerModel<T>的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />esQueryList：动态查询条件 |
| GetPagerFields | 获取分页数据（返回指定字段的值） | <T>(EsPagerConModel esPagerCon, List<string> speFields, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerDicModel的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />esQueryList：动态查询条件 |
| GetPagerFieldsAsync | 获取分页数据（返回指定字段的值，异步） | <T>(EsPagerConModel esPagerCon, List<string> speFields, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为EsPagerDicModel的数据对象 | T：泛型对象<br />esPagerCon：分页条件<br />speFields：只返回设置字段的值，如：new List<string> { "SampleId", "SampleName" }<br />esQueryList：动态查询条件 |
6.9、📋分组统计查询方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetGroupValues | 单个字段分组，并返回该字段的所有值集合 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<string>的集合，格式如：["分类1","分类2"] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupValuesAsync | 单个字段分组，并返回该字段的所有值集合，异步 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<string>的集合，格式如：["分类1","分类2"] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupCount | 单个字段分组，并返回该字段的所有值和数量集合 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"Name":"分类1","Count":100}] | T：泛型对象<br />field：要分组的字段，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetGroupCountAsync | 单个字段分组，并返回该字段的所有值和数量集合，异步 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}] | T：泛型对象<br />groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" }<br />esQueryList：动态查询条件 |
| GetGroupsCountAsync | 多个字段分组，异步 | <T>(List<string> groupFields, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为List<Dictionary<string, object>>的集合，格式如：[{"col1":"val1","col2":"val2","GroupCount":100}] | T：泛型对象<br />groupFields：要分组的字段集合，如：new List<string> { "col1", "col2" }<br />esQueryList：动态查询条件 |
| GetGroupsDateMonth | 日期字段分组，按月统计 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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", params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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.10、📜获取总条数、最大、最小、求和或平均值等方法
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| GetCount | 获取符合条件的数据总条数 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数 | T：泛型对象<br />esQueryList：动态查询条件 |
| GetCountAsync | 获取符合条件的数据总条数（异步） | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为总条数 | T：泛型对象<br />esQueryList：动态查询条件 |
| GetStatiCount | 获取某字段的最大值、最小值、求和、平均值和总数等 | <T>(Expression<Func<T, object>> field, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含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, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"Count":100,"Sum":999,"Max":150,"Min":10,"Avg":200} | T：泛型对象<br />field：要求和、最大值、最小值和平均值的字段B，格式如：m=>m.col1<br />esQueryList：动态查询条件 |
| GetStatiSumMulti | 获取某些字段相加的多个总和 | <T>(List<EsStatisticalSumMultiModel<T>> fieldCons, bool is2Dec, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类1":100,"分类2":200} | T：泛型对象<br />fieldCons：统计的某些字段多个总和的条件集合<br />is2Dec：是否将总和结果保留2为小数，false则将保持原小数返回<br />esQueryList：动态查询条件 |
| GetStatiSumMultiAsync | 获取某些字段相加的多个总和（异步） | <T>(List<EsStatisticalSumMultiModel<T>> fieldCons, bool is2Dec, params EsQueryModel<T>[] esQueryList) | 返回元组对象，包含3个值，第一个为是否成功，第二个为失败的提示信息，第三个为统计数据，格式为{"分类1":100,"分类2":200} | T：泛型对象<br />fieldCons：统计的某些字段多个总和的条件集合<br />is2Dec：是否将总和结果保留2为小数，false则将保持原小数返回<br />esQueryList：动态查询条件 |
6.11、💰查询条件
在上面的方法中，基本都涉及到了关于查询条件的参数，在此专门对查询条件的使用进行说明。
声明查询条件：
我们使用EsQueryModel对象来声明一个查询条件，如下所示：
//TestElasticSearchModel为泛型实体
var andCons1 = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
添加查询条件：
接下来我们就可以给刚才声明的andCons1添加具体的条件了，如下所示的代码代表Id 大于或等于 340506710462542 并且 UserAge 小于或等于 60：
//查询条件：(Id >= 340506710462542 AND UserAge <= 60)
andCons1.QueryCon
.AddGte(m => m.Id, 340506710462542)
.AddLte(m => m.UserAge, 60);
组合条件：
上述的例子，我们只声明了一个组合条件，如果需要多个组合条件一起使用，则声明多个即可，如下所示的代码代表(Id 大于或等于 340506710462542 并且 UserAge 小于或等于 60) 或者(Id 等于 340506710462539 或者 Id 等于 340506710462538)：
//声明组合条件1
var andCons1 = new EsQueryModel<TestElasticSearchModel>
{
//代表和上一个组合条件的连接关系（由于andCons1是第一个声明的组合条件，此设置可忽略）
PrevConType = EsQueryType.And,
//代表组合条件1（andCons1）自身各个子条件的连接关系，此处设置的是And关系
QueryType = EsQueryType.And
};
//声明组合条件2
var andCons2 = new EsQueryModel<TestElasticSearchModel>
{
//代表和上一个组合条件1（andCons1）是OR的连接关系
PrevConType = EsQueryType.Or,
//代表组合条件2（andCons2）自身各个子条件的连接关系，此处设置的是Or关系
QueryType = EsQueryType.Or
};
//组合条件1和组合条件2结合起来使用的效果类似SQL：(Id >= 340506710462542 AND UserAge <= 60) OR (Id = 340506710462539 OR Id = 340506710462538)
andCons1.QueryCon
.AddGte(m => m.Id, 340506710462542)//添加>=子条件
.AddLte(m => m.UserAge, 60); //添加<=子条件
andCons2.QueryCon
.AddEqu(m => m.Id, 340506710462539) //添加=子条件
.AddEqu(m => m.Id, 340506710462538);//添加=子条件
//同步
var retDeleteModelBy = _quickElasticSearch.DeleteModelBy<TestElasticSearchModel>(andCons1, andCons2);
//异步
var retDeleteModelByAsync = await _quickElasticSearch.DeleteModelByAsync<TestElasticSearchModel>(andCons1, andCons2);
EsQueryModel说明：
- PrevConType：和上一个EsQueryModel之间的连接类型（AND或OR操作，默认为AND操作）；
- QueryType：查询条件集合的连接类型，针对QueryCon而言（AND或OR操作，默认为AND操作）；
- QueryCon：查询条件集合。
查询条件扩展方法：
| 方法名称 | 方法说明 | 方法参数 | 返回值 | 备注 |
|---|---|---|---|---|
| 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 andCons = 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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddEqu(m ⇒ m.AgeExp, "7"); |
| 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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddNotEqu(m ⇒ m.AgeExp, "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.AgeExp<br />values：查询的具体值<br /><br />使用示例：andCons.AddNotEqu(m ⇒ m.AgeExp, 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.AgeExp 或 m=>new [] {m.EngPart, m.TestType}<br />value：查询的关键字<br /><br />使用示例：andCons.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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddGt(m ⇒ m.AgeExp, 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 />使用示例：andCons.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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddGte(m ⇒ m.AgeExp, 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 />使用示例：andCons.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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddLt(m ⇒ m.AgeExp, 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 />使用示例：andCons.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.AgeExp<br />value：查询的具体值<br /><br />使用示例：andCons.AddLte(m ⇒ m.AgeExp, 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 />使用示例：andCons.AddLte(m ⇒ m.CreateTime, "2022-10-12 14:10:26"); |
分页查询条件：
我们在使用分页方法的时候，第一个参数需要传入分页查询参数EsPagerConModel，如下所示：
//分页条件
var pagerCon = new EsPagerConModel
{
PageIndex = 1,
PageSize = 15,
OrderField = "Id",
OrderType = "desc"
};
//查询条件
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetPager = _quickElasticSearch.GetPager<TestElasticSearchModel>(pagerCon, andCons);
//异步
var retGetPagerAsync = await _quickElasticSearch.GetPagerAsync<TestElasticSearchModel>(pagerCon, andCons);
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<TestElasticSearchModel>>()
{
new() { AsName="分类1",Fields=new List<Expression<Func<TestElasticSearchModel, object>>>{ m=>m.Money } },
new() { AsName="分类2",Fields=new List<Expression<Func<TestElasticSearchModel, object>>>{ m => m.Money, m => m.MoneyOth } }
};
var andCons = new EsQueryModel<TestElasticSearchModel>
{
PrevConType = EsQueryType.And,
QueryType = EsQueryType.And
};
//查询条件：(Id >= 1)
andCons.QueryCon
.AddGte(m => m.Id, 1);
//同步
var retGetStatiSumMulti = _quickElasticSearch.GetStatiSumMulti<TestElasticSearchModel>(fieldCons, true, andCons);
//异步
var retGetStatiSumMultiAsync = await _quickElasticSearch.GetStatiSumMultiAsync<TestElasticSearchModel>(fieldCons, true, andCons);
EsStatisticalSumMultiModel说明：
- AsName：某几个字段相加总和最后返回的Key名称；
- Fields：某几个字段相加的字段集合。
| 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.