.NetCore上使用ElasticSeach的一个helper类(4)

最新推荐文章于 2021-12-16 15:39:22 发布
最新推荐文章于 2021-12-16 15:39:22 发布
阅读量364 收藏
点赞数

640?wx_fmt=png

ElasticSeach 访问封装的服务类，有需要的可以直接COPY过去用

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;	
    }	
}

原文链接：

https://blog.csdn.net/qq_38762313/article/details/90474488

640?wx_fmt=jpeg

hailang2ll
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于Linux系统的Elasticsearch-6.2.4 封装.Net调用Elasticsearch的帮助类（六）
LDH 博客
09-04 5924
※ 简介   Elasticsearch官网提供两个DLL供.Net调用，一个是Elasticsearch.Net，另一个Nest；之前项目用的是Elasticsearch.Net，但个人感觉用起来没有Nest方便。    ※区别   1. Elasticsearch.Net是一个非常底层且灵活的客户端，它不在意你如何的构建自己的请求和响应。它非常抽象，因此所有的Elasticsearch API被表示为方法，没有太多关于你想如何构建json/request/response对象的东东，并且它还内置了可配置
.NETCore WebAPI中使用Swagger持久化存储Token
最新发布
08-02
1、ASP.NETCore WebAPI使用Swagger，使用Cookie持久化存储Token，解决每次刷新需要重新输入Token授权。 2、包含进入swagger首页前，需要进行登录的login.html前台静态页面。 Swagger是一个规范且完整的框架，用于...
【四】在Asp.Netcore上使用ElasticSeach的一个helper类
猴子_net的博客
05-23 2612
目录 【一】在window上部署ElasticSearch并注册成服务 【二】在window上部署kibana并注册成服务 【三】在Asp.Netcore上使用ElasticSearch 【四】在Asp.Netcore上使用ElasticSeach的一个helper类 ElasticSeach 访问封装的服务类 IElasticSearch类的代码如下： ...
使用elasticsearch的帮助类
henry的专栏
03-26 631
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 1096
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;
.netcore6 的Autofac使用实例 接口多个实例 ResolveByKey作用域
05-24
`ClassTest.cs` 可能包含了需要依赖注入的类，其中可能定义了使用 `InstancePerLifetimeScope` 注解的接口实现。例如： ```csharp public interface IService { // ... } public class Service : IService { // ...
.NETCore微服务架构Steeltoe使用（基于SpringCloud）
01-27
标题中的".NETCore微服务架构Steeltoe使用（基于SpringCloud）"指的是使用Steeltoe框架构建.NET Core微服务，并将其与Spring Cloud生态系统集成。这是一个跨平台的开发工具集，帮助开发者在.NET Core环境中实现...
.NetCore Petapoco（SqlServer） T4模板(含表字段注释).rar
08-24
.NetCore是微软推出的新一代跨平台开发框架，而Petapoco则是一个轻量级、高效的ORM库，它适用于快速开发和小型项目。本文将深入探讨如何在.NetCore环境中使用Petapoco，并特别关注T4模板在Sqlserver数据库中的应用，...
Elasticsearch工具类
04-08
Elasticsearch工具类，支持通过标签注释实体类并通过工具类实现对es的映射（把po的结构导入es），和对es的增删查改，包括分页，scroll读取，关联查询等。
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 504
安装NuGet包，搜索Nest 并安装如上图：选择最新稳定版本安装注：操作Json的话 还要下载一个Newtonsoft.Json 包开始使用这里是以服务的方式进行实现的...
.Net Core ElasticSearch+NEST
小堂子这厢有礼了
03-23 755
​Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示
ElasticSearch——.NET客户端
世界中心的专栏
11-24 2552
NEST elasticsearch的官方高级.NET客户端。 它旨在成为一个坚实，强类型的客户端，具有非常简洁的API。 内部使用低级Elasticsearch.Net客户端的高级客户端使用流畅的接口和对象初始化器语法来映射对强类型对象的请求和响应带有一个非常强大的查询DSL，与Elasticsearch一一对应利用.NET特性（它们有意义）（即，协变的IEnumerable 结果类
ElasticSearch-.net平台下c#操作ElasticSearch详解
u014712365的博客
05-18 598
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 3255
一、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 2342
环境 .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 572
一、基础查询 //条件单个 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
使用.netcore 写一个webapi项目
07-14
要使用 .NET Core 编写一个 Web API 项目，你可以按照以下步骤进行操作： 1. 安装 .NET Core SDK：首先，保你已经安装了最新的 .NET Core SDK。你可以从 Microsoft方网站（https://dotnet.microsoft.com/download）下载并安装适合你操作系统的版本。 2. 创建 Web API 项目：打开命令行终端或者使用集成开发环境（IDE）如 Visual Studio Code，在你想要创建项目的目录下执行以下命令： ``` dotnet new webapi -n YourProjectName ``` 这将在当前目录下创建一个名为 YourProjectName 的新 Web API 项目。 3. 进入项目目录：执行以下命令进入项目目录： ``` cd YourProjectName ``` 4. 编写 API 控制器：在 Controllers 文件夹中创建一个新的控制器文件（例如 `ValuesController.cs`），并按照需要实现你的 API 逻辑。例如，你可以创建一个简单的 GET 请求处理方法： ```csharp using Microsoft.AspNetCore.Mvc; namespace YourProjectName.Controllers { [ApiController] [Route("api/[controller]")] public class ValuesController : ControllerBase { [HttpGet] public ActionResult<string> Get() { return "Hello, World!"; } } } ``` 5. 运行项目：返回项目根目录，并执行以下命令来运行项目： ``` dotnet run ``` 这将启动一个本地开发服务器，并监听默认的端口号（通常是 5000）。 6. 测试你的 API：打开浏览器或使用工具如 Postman，访问 `http://localhost:5000/api/values`（如果你修改了默认的端口号，请相应地更改 URL），你将会看到返回的 "Hello, World!"。 这只是一个简单的示例，你可以根据你的需求添加更多的控制器和路由。你也可以使用 Entity Framework Core 或其他库来访问数据库，实现更复杂的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值