【四】在Asp.Netcore上使用ElasticSeach的一个helper类

最新推荐文章于 2021-12-16 15:39:22 发布
最新推荐文章于 2021-12-16 15:39:22 发布
阅读量2.6k 收藏 3
点赞数 1
分类专栏： Asp.netcore ElasticSearch 文章标签： Asp.netcore netcore ElasticSearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38762313/article/details/90474488
版权

目录

   【一】在window上部署ElasticSearch并注册成服务

   【二】在window上部署kibana并注册成服务

   【三】在Asp.Netcore上使用ElasticSearch

   【四】在Asp.Netcore上使用ElasticSeach的一个helper类

ElasticSeach 访问封装的服务类

IElasticSearch类的代码如下：

    /// <summary>
    /// 访问ElasticSearch服务接口类
    /// Monkey 2019/05/23
    /// </summary>
    public interface IESSever
    {
        /// <summary>
        /// Linq查询的官方Client
        /// </summary>
        IElasticClient ElasticLinqClient { get; set; }
       
        /// <summary>
        /// Js查询的官方Client
        /// </summary>
        IElasticLowLevelClient ElasticJsonClient { get; set; }

        /// <summary>
        /// 封装后的linq的查询方式
        /// </summary>
        /// <typeparam name="T">要查询和返回的Json</typeparam>
        /// <param name="indexName">index的名称</param>
        /// <param name="typeName">type的名称</param>
        /// <param name="selector">linq内容</param>
        /// <returns></returns>
        Task<List<T>> SearchAsync<T>(string indexName, string typeName, Func<QueryContainerDescriptor<T>, QueryContainer> selector = null) where T : class;

        /// <summary>
        /// 封装后的Json的查询方式
        /// </summary>
        /// <param name="indexName">index的名称</param>
        /// <param name="typeName">type的名称</param>
        /// <param name="jsonString">json字符串</param>
        /// <returns></returns>
        Task<JToken> SearchAsync(string indexName, string typeName, string jsonString);

        /// <summary>
        /// 封装后的创建index
        /// </summary>
        /// <param name="indexName"></param>
        /// <param name="shards">分片数量，即数据块最小单元</param>
        /// <returns></returns>
        Task<bool> CreateIndexAsync(string indexName, int shards = 5);

        /// <summary>
        /// 封装后的删除index
        /// </summary>
        /// <param name="indexName"></param>
        /// <returns></returns>
        Task<bool> DeleteIndexAsync(string indexName);

        /// <summary>
        /// 插入文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">文档名称</param>
        /// <param name="objectDocment">文档内容</param>
        /// <param name="_id">自定义_id</param>
        /// <returns></returns>
        Task<bool> InsertDocumentAsync(string indexName, string typeName, object objectDocment, string _id = "");
        /// <summary>
        /// 批量插入文档
        /// </summary>
        /// <typeparam name="T">文档格式</typeparam>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName"></param>
        /// <param name="listDocment">数据集合</param>
        /// <returns></returns>
        Task<bool> InsertListDocumentAsync(string indexName, string typeName, List<object> listDocment);


        /// <summary>
        /// 删除一个文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="_id">elasticsearch的id</param>
        /// <returns></returns>
        Task<bool> DeleteDocumentAsync(string indexName, string typeName, string _id);


        /// <summary>
        /// 更新文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="_id">elasticsearch的id</param>
        /// <param name="objectDocment">单条数据的所有内容</param>
        /// <returns></returns>
        Task<bool> UpdateDocumentAsync(string indexName, string typeName, string _id, object objectDocment);

        /// <summary>
        /// 批量更新文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="listDocment">数据集合，注：docment 里要有_id</param>
        /// <returns></returns>

        Task<bool> UpdateListDocumentAsync(string indexName, string typeName,List<object> listDocment);
    }

ElasticSearch的方法实现

 

    /// <summary>
    ///访问ElasticSearch服务类
    /// Monkey 2019-05-16
    /// </summary>
    public class ESSever : IESSever
    {
        /// <summary>
        /// Linq查询的官方Client
        /// </summary>
        public IElasticClient ElasticLinqClient { get; set; }
        /// <summary>
        /// Js查询的官方Client
        /// </summary>
        public IElasticLowLevelClient ElasticJsonClient { get; set; }

        public IMemoryCache memoryCache { get; set; }


        public ESSever(IConfiguration configuration, IMemoryCache memoryCache_arg)
        {
            memoryCache = memoryCache_arg;
            var uris = configuration["ElasticSearchContext:Url"].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(x => new Uri(x));
            var connectionPool = new StaticConnectionPool(uris);
            var settings = new ConnectionSettings(connectionPool).RequestTimeout(TimeSpan.FromSeconds(30));//.BasicAuthentication("elastic", "n@@W#RJQ$z1#")
            this.ElasticJsonClient = new ElasticLowLevelClient(settings);
            this.ElasticLinqClient = new ElasticClient(settings);
        }



        /// <summary>
        /// 封装后的linq的查询方式
        /// </summary>
        /// <typeparam name="T">要查询和返回的Json</typeparam>
        /// <param name="indexName">index的名称</param>
        /// <param name="typeName">type的名称</param>
        /// <param name="selector">linq内容</param>
        /// <returns></returns>
        public async Task<List<T>> SearchAsync<T>(string indexName, string typeName, Func<QueryContainerDescriptor<T>, QueryContainer> selector = null) where T : class
        {
            var list = await ElasticLinqClient.SearchAsync<T>(option => option.Index(indexName.ToLower()).Type(typeName).Query(selector));
            return list.Documents.ToList();
        }


        /// <summary>
        /// 封装后的Json的查询方式
        /// </summary>
        /// <param name="indexName">index的名称</param>
        /// <param name="typeName">type的名称</param>
        /// <param name="jsonString">json字符串</param>
        /// <returns>返回Jobject的内容</returns>
        public async Task<JToken> SearchAsync(string indexName, string typeName, string jsonString)
        {
            var stringRespones = await ElasticJsonClient.SearchAsync<StringResponse>(indexName.ToLower(), typeName, jsonString);
            var jobject = JObject.Parse(stringRespones.Body);
            var total = Convert.ToInt32(jobject["hits"]["total"].ToString());
            if (total > 0)
            {
                string json = string.Empty;
                var sourceArg = jobject["hits"]["hits"];
                foreach (var source in sourceArg)
                {
                    string sourceJson = source["_source"].ToString().Substring(1, source["_source"].ToString().Length - 1);
                    sourceJson = "{ \"_id\":\"" + source["_id"] + "\"," + sourceJson;
                    if (json.Length <= 0)
                        json += sourceJson;
                    else
                        json += "," + sourceJson;


                }

                return JToken.Parse("[" + json + "]");
            }
            return null;
        }


        /// <summary>
        /// 封装后的创建index
        /// </summary>
        /// <param name="indexName"></param>
        /// <param name="shards">分片数量，即数据块最小单元</param>
        /// <returns></returns>
        public async Task<bool> CreateIndexAsync(string indexName, int shards = 5)
        {
            var isHaveIndex = await IsIndexExsit(indexName.ToLower());
            if (!isHaveIndex)
            {
                var stringResponse = await ElasticJsonClient.IndicesCreateAsync<StringResponse>(indexName.ToLower(),
                        PostData.String($"{{\"settings\" : {{\"index\" : {{\"number_of_replicas\" : 0, \"number_of_shards\":\"{shards}\",\"refresh_interval\":\"-1\"}}}}}}"));
                var resObj = JObject.Parse(stringResponse.Body);
                if ((bool)resObj["acknowledged"])
                {
                    return true;
                }
            }
            else
            {
                return true;
            }
            return false;
        }


        /// <summary>
        /// 检测索引是否已经存在
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public async Task<bool> IsIndexExsit(string index)
        {
            bool flag = false;
            StringResponse resStr = null;
            try
            {
                resStr = await ElasticJsonClient.IndicesExistsAsync<StringResponse>(index);
                if (resStr.HttpStatusCode == 200)
                {
                    flag = true;
                }
            }
            catch (Exception ex)
            {
            }

            return flag;
        }

        /// <summary>
        /// 封装后的删除index
        /// </summary>
        /// <param name="indexName"></param>
        /// <returns></returns>
        public async Task<bool> DeleteIndexAsync(string indexName)
        {
            var stringRespones = await ElasticJsonClient.IndicesDeleteAsync<StringResponse>(indexName.ToLower());
            var resObj = JObject.Parse(stringRespones.Body);
            if ((bool)resObj["acknowledged"])
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 插入单个文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">文档名称</param>
        /// <param name="objectDocment">文档内容</param>
        /// <param name="_id">自定义_id</param>
        /// <returns></returns>
        public async Task<bool> InsertDocumentAsync(string indexName, string typeName,  object objectDocment,string _id = "")
        {
            var stringRespones = new StringResponse();
            if (_id.Length > 0)
                stringRespones = await ElasticJsonClient.IndexAsync<StringResponse>(indexName.ToLower(), typeName, _id, PostData.String(JsonConvert.SerializeObject(objectDocment)));
            else
                stringRespones = await ElasticJsonClient.IndexAsync<StringResponse>(indexName.ToLower(), typeName, PostData.String(JsonConvert.SerializeObject(objectDocment)));
            var resObj = JObject.Parse(stringRespones.Body);
            if ((int)resObj["_shards"]["successful"] > 0)
            {
                return true;
            }
            return false;
        }


        /// <summary>
        /// 优化写入性能
        /// </summary>
        /// <param name="index"></param>
        /// <param name="refresh"></param>
        /// <param name="replia"></param>
        /// <returns></returns>
        public async Task<bool> SetIndexRefreshAndReplia(string index, string refresh = "30s", int replia = 1)
        {
            bool flag = false;
            StringResponse resStr = null;
            try
            {
                if (memoryCache.TryGetValue("isRefreshAndReplia", out bool isrefresh))
                {
                    if (!isrefresh)
                    {
                        resStr = await ElasticJsonClient.IndicesPutSettingsAsync<StringResponse>(index.ToLower(),
                     PostData.String($"{{\"index\" : {{\"number_of_replicas\" : {replia},\"refresh_interval\":\"{refresh}\"}}}}"));
                        var resObj = JObject.Parse(resStr.Body);
                        if ((bool)resObj["acknowledged"])
                        {
                            flag = true;
                            memoryCache.Set("isRefreshAndReplia", true);
                        }
                    }
                }
                else
                {
                    resStr = await ElasticJsonClient.IndicesPutSettingsAsync<StringResponse>(index.ToLower(),
                    PostData.String($"{{\"index\" : {{\"number_of_replicas\" : {replia},\"refresh_interval\":\"{refresh}\"}}}}"));
                    var resObj = JObject.Parse(resStr.Body);
                    if ((bool)resObj["acknowledged"])
                    {
                        flag = true;
                        memoryCache.Set("isRefreshAndReplia", true);
                    }
                }

            }
            catch (Exception ex)
            {
            }
            return flag;
        }

        /// <summary>
        /// 批量插入文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName"></param>
        /// <param name="listDocment">数据集合</param>
        /// <returns></returns>
        public async Task<bool> InsertListDocumentAsync(string indexName, string typeName, List<object> listDocment)
        {
            var isRefresh = await SetIndexRefreshAndReplia(indexName.ToLower());
            if (isRefresh)
            {
                List<string> list = new List<string>();
                foreach (var ob in listDocment)
                {
                    //{"index":{"_index":"meterdata","_type":"autoData"}}
                    var indexJsonStr = new { index = new { _index = indexName.ToLower(), _type = typeName } };
                    list.Add(JsonConvert.SerializeObject(indexJsonStr));
                    list.Add(JsonConvert.SerializeObject(ob));
                }

                var stringRespones = await ElasticJsonClient.BulkAsync<StringResponse>(indexName.ToLower(), typeName, PostData.MultiJson(list));
                var resObj = JObject.Parse(stringRespones.Body);
                if (!(bool)resObj["errors"])
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 删除一个文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="_id">elasticsearch的id</param>
        /// <returns></returns>
        public async Task<bool> DeleteDocumentAsync(string indexName, string typeName, string _id)
        {
            bool flag = false;
            StringResponse resStr = null;
            try
            {
                resStr = await ElasticJsonClient.DeleteAsync<StringResponse>(indexName.ToLower(), typeName, _id);
                var resObj = JObject.Parse(resStr.Body);
                if ((int)resObj["_shards"]["total"] == 0 || (int)resObj["_shards"]["successful"] > 0)
                {
                    flag = true;
                }
            }
            catch (Exception ex)
            {
            }

            return flag;
        }

        / <summary>
        / 更新文档  删除重建法
        / </summary>
        / <param name="indexName">索引名称</param>
        / <param name="typeName">类别名称</param>
        / <param name="_id">elasticsearch的id</param>
        / <param name="objectDocment">单条数据的所有内容</param>
        / <returns></returns>
        //public async Task<bool> UpdateDocumentAsync(string indexName, string typeName, string _id, object objectDocment)
        //{
        //    bool flag = false;
        //    try
        //    {
        //        string json = JsonConvert.SerializeObject(objectDocment);
        //        if (json.IndexOf("[") == 0)
        //        {
        //            var objectDocmentOne = JToken.Parse(json);
        //            json = JsonConvert.SerializeObject(objectDocmentOne[0]);
        //            int idInt = json.IndexOf("\"_id");
        //            string idJson = json.Substring(idInt, json.IndexOf(_id) + _id.Length + 1);
        //            json = json.Replace(idJson, "");
        //        }
        //        var isOk = await DeleteDocumentAsync(indexName,typeName,_id);
        //        if (isOk)
        //        {
        //            flag = await InsertDocumentAsync(indexName,typeName, JToken.Parse(json), _id);
        //        }

        //    }
        //    catch {}
        //    return flag;
        //}

        /// <summary>
        /// 更新文档  
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="_id">elasticsearch的id</param>
        /// <param name="objectDocment">单条数据的所有内容</param>
        /// <returns></returns>
        public async Task<bool> UpdateDocumentAsync(string indexName, string typeName, string _id, object objectDocment)
        {
            bool flag = false;
            try
            {
                string json = JsonConvert.SerializeObject(objectDocment);
                if (json.IndexOf("[") == 0)
                {
                    var objectDocmentOne = JToken.Parse(json);
                    json = JsonConvert.SerializeObject(objectDocmentOne[0]);
                }
                int idInt = json.IndexOf("\"_id");
                if (idInt > 0)
                {
                    string idJson = json.Substring(idInt, json.IndexOf(_id) + _id.Length + 1);
                    json = json.Replace(idJson, "");
                }
                //{ "update" : { "_id" : "5cc2d9cf6d2d99ce58007201" } }
                //{ "doc" : { "Sex" : "王五111" } }
                List<string> list = new List<string>();
                list.Add("{\"update\":{\"_id\":\""+_id+"\"}}");
                list.Add("{\"doc\":"+json+"}");
                var stringRespones = await ElasticJsonClient.BulkAsync<StringResponse>(indexName.ToLower(), typeName, PostData.MultiJson(list));
                var resObj = JObject.Parse(stringRespones.Body);
                if (!(bool)resObj["errors"])
                {
                    return true;
                }
            }
            catch { }
            return flag;
        }

        /// <summary>
        /// 批量更新文档
        /// </summary>
        /// <param name="indexName">索引名称</param>
        /// <param name="typeName">类别名称</param>
        /// <param name="listDocment">数据集合，注：docment 里要有_id,否则更新不进去</param>
        /// <returns></returns>

        public async Task<bool> UpdateListDocumentAsync(string indexName, string typeName, List<object> listDocment)
        {
            bool flag = false;
            try
            {
                List<string> list = new List<string>();
                foreach (var objectDocment in listDocment)
                {
                    string json = JsonConvert.SerializeObject(objectDocment);
                    JToken docment = null;
                    var objectDocmentOne = JToken.Parse(json);
                    docment = objectDocmentOne;
                    if (json.IndexOf("[") == 0)
                    {
                        json = JsonConvert.SerializeObject(objectDocmentOne[0]);
                        docment = objectDocmentOne[0];
                    }
                    string _id = docment["_id"].ToString();
                    int idInt = json.IndexOf("\"_id");
                    if (idInt > 0)
                    {
                        string idJson = json.Substring(idInt, json.IndexOf(_id) + _id.Length + 1);
                        json = json.Replace(idJson, "");
                    }
                    //{ "update" : { "_id" : "5cc2d9cf6d2d99ce58007201" } }
                    //{ "doc" : { "Sex" : "王五111" } }
                    list.Add("{\"update\":{\"_id\":\"" + _id + "\"}}");
                    list.Add("{\"doc\":" + json + "}");
                }
                var stringRespones = await ElasticJsonClient.BulkAsync<StringResponse>(indexName.ToLower(), typeName, PostData.MultiJson(list));
                var resObj = JObject.Parse(stringRespones.Body);
                if (!(bool)resObj["errors"])
                {
                    return true;
                }
            }
            catch { }
            return flag;
        }

    }

 

 

 

dotnet_Monkey
关注
专栏目录
基于Linux系统的Elasticsearch-6.2.4 封装.Net调用Elasticsearch的帮助类（六）
LDH 博客
09-04 5932
※ 简介   Elasticsearch官网提供两个DLL供.Net调用，一个是Elasticsearch.Net，另一个Nest；之前项目用的是Elasticsearch.Net，但个人感觉用起来没有Nest方便。    ※区别   1. Elasticsearch.Net是一个非常底层且灵活的客户端，它不在意你如何的构建自己的请求和响应。它非常抽象，因此所有的Elasticsearch API被表示为方法，没有太多关于你想如何构建json/request/response对象的东东，并且它还内置了可配置
Elasticsearch工具类
04-08
Elasticsearch工具类，支持通过标签注释实体类并通过工具类实现对es的映射（把po的结构导入es），和对es的增删查改，包括分页，scroll读取，关联查询等。
使用elasticsearch的帮助类
henry的专栏
03-26 636
Elasticsearch 提供帮助类来生成JSON. import static org.elasticsearch.common.xcontent.XContentFactory.*; XContentBuilder builder = jsonBuilder() .startObject() .field("user", "kimchy") .fi
ElasticSearch入门 附.Net Core例子
weixin_34174322的博客
09-06 2099
1.什么是ElasticSearch? Elasticsearch是基于Lucene的搜索引擎。它提供了一个分布式，支持多租户的全文搜索引擎，它具有HTTP Web界面和无模式JSON文档。 Elasticsearch是用Java开发的，根据Apache许可条款作为开源发布。 ----来自维基百科的解释 我个人的理解是Elasticsearch（以下简称...
.net core Elasticsearch.Net基本操作
zhaoyahui_666的博客
12-16 1128
1.加入依赖 Elasticsearch.model Elasticsearch.Net 2.编写工具类 using Elasticsearch.model; using Elasticsearch.Net; using Nest; namespace Elasticsearch.config { public class ElasticsearchHelper { private static ElasticClient? _client = null;
.NETCore WebAPI中使用Swagger持久化存储Token
最新发布
08-02
1、ASP.NETCore WebAPI使用Swagger，使用Cookie持久化存储Token，解决每次刷新需要重新输入Token授权。 2、包含进入swagger首页前，需要进行登录的login.html前台静态页面。 Swagger是一个规范且完整的框架，用于...
餐厅营业查看系统Java源码-ASP.NETCore2.1Architecture:一个使用ASP.NETCore2.1架构的应用程序
06-06
一个使用ASP.NETCore2.1架构的应用3.0升级概述 在您开始本课程之前，您需要了解一个有趣的事实。 我使用 ASP.NET Core 2.1 版录制了这门课程。 自从我录制了这门课程，微软已经发布了 ASP.NET Core 3.0。 2.1 版（我...
asp.netCore3.1微信登录
12-08
asp.netCore3.1+微信登录 WechatHelper 是主要代码。第1步：请求code（前端） 第2步：前端通过获取的code请求API获取access_token（第2步之后都是后台API写代码） 第3步：API通过access_token调用接口 第4步：获取...
asp.netCore+vue +SignalR
12-08
接着，定义一个Hub类，这个类继承自Microsoft.AspNetCore.SignalR.Hub，它是SignalR的主要通信实体，包含了客户端和服务器间的所有方法。在服务器端，可以通过Hub的方法向所有连接的客户端或特定客户端发送消息；在...
ASP.NETCore v5.0.1
12-28
ASP.NET Core应用程序在.NET Core（一个的，跨平台的开源应用程序运行时）上运行。它的架构旨在为部署到云或本地运行的应用程序提供优化的开发框架。它由具有最小开销的模块化组件组成，因此您在构建解决方案时可以...
miniblog-elasticsearch:将Elasticsearch与ASP.NET Core结合使用
05-02
将Elasticsearch与ASP.NET Core和Docker结合使用 结合的博客文章的示例代码。 使用MiniBlog模板创建一个新的ASP.NET Core项目，并在其中添加Elasticsearch功能。 是开源项目。 是的产品。
elasticsearchDotnetCoreAPI
02-22
elasticsearchDotnetCoreAPI
.Netcore上简单使用ElasticSearch(3)
hailang2ll的专栏
10-25 508
安装NuGet包，搜索Nest 并安装如上图：选择最新稳定版本安装注：操作Json的话 还要下载一个Newtonsoft.Json 包开始使用这里是以服务的方式进行实现的...
.Net Core ElasticSearch+NEST
小堂子这厢有礼了
03-23 777
​Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示
ElasticSearch——.NET客户端
世界中心的专栏
11-24 2557
NEST elasticsearch的官方高级.NET客户端。 它旨在成为一个坚实，强类型的客户端，具有非常简洁的API。 内部使用低级Elasticsearch.Net客户端的高级客户端使用流畅的接口和对象初始化器语法来映射对强类型对象的请求和响应带有一个非常强大的查询DSL，与Elasticsearch一一对应利用.NET特性（它们有意义）（即，协变的IEnumerable 结果类
ElasticSearch-.net平台下c#操作ElasticSearch详解
u014712365的博客
05-18 626
ElasticSearch系列学习 ElasticSearch第一步-环境配置 ElasticSearch第二步-CRUD之Sense ElasticSearch第三步-中文分词 ElasticSearch第四步-查询详解 ElasticSearch第五步-.net平台下c#操作ElasticSearch详解 前面我们讲解了关于ElasticSearch的安装配置，以及CRUD 本章我将讲解怎...
elasticsearch系列七：ES Java客户端-ES Java client（ES Client 简介、Java REST Client、Java Client、Spring)
WorldMvp的专栏
10-26 3336
一、ES Client 简介 1.ES是一个服务，采用C/S结构 2. 回顾 ES的架构 3. ES支持的客户端连接方式 3.1 REST API ，端口 9200 　　这种连接方式对应于架构图中的RESTful style API这一层，这种客户端的连接方式是RESTful风格的，使用http的方式进行连接。 3.2 Transport 连接 端口 9300 这种连接方式对应于架构图中的Transport这一层，这种客户端连接方式是直接连接ES的节点，使用T...
.Net Core平台Elasticsearch客户端NEST
菜鸟厚非
09-18 2394
环境 .NET Core 3.1 + NEST 7.9（SourceCode） + ES 7.X 具体用法 客户端 NEST 客户端有 IElasticClient、IElasticLowLevelClient 两种类型 public static IElasticClient _ElasticLinqClient { get; set; } public static IElasticLowLevelClient _ElasticJsonClient { get; set; } ​​​​ 连接
.NET CORE【ES】
fei飞来了
09-23 584
一、基础查询 //条件单个 var mustQuerys = new List<Func<QueryContainerDescriptor<RequestFunds>, QueryContainer>>(); //条件集合 if (input.BrokerIds.Any()) { mustQuerys.Add(q => q.Terms(t => t.Field(f => f.BrokerId).Terms(input.BrokerId
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值