.net NEST7.17.0 ES客户端帮助类

分页模型

public class PageModel<T> where T : class
    {
        /// <summary>
        /// 总数
        /// </summary>
        public long TotalCount { get; set; }

        /// <summary>
        /// 文档数据
        /// </summary>
        public List<T> Data { get; set; }
    }

帮助类

public static class EsUtil
    {
        /// <summary>
        /// 获取ElasticClient
        /// </summary>
        /// <param name="url">ElasticSearch服务器地址</param>
        /// <param name="defaultIndex">默认索引名称</param>
        /// <returns></returns>
        public static ElasticClient Client(string url, string defaultIndex = "")
        {
            Uri uri = new Uri(url);
            ConnectionSettings setting = new ConnectionSettings(uri);

            if (!string.IsNullOrWhiteSpace(defaultIndex))
            {
                setting.DefaultIndex(defaultIndex);
            }


            return new ElasticClient(setting);
        }

        /// <summary>
        /// 获取ElasticClient
        /// </summary>
        /// <param name="urls">ElasticSearch集群地址</param>
        /// <param name="defaultIndex">默认索引名称</param>
        /// <returns></returns>
        public static ElasticClient Client(string[] urls, string defaultIndex = "")
        {
            Uri[] uris = urls.Select(h => new Uri(h)).ToArray();
            SniffingConnectionPool pool = new SniffingConnectionPool(uris);

            ConnectionSettings setting = new ConnectionSettings(pool);

            if (!string.IsNullOrWhiteSpace(defaultIndex))
            {
                setting.DefaultIndex(defaultIndex);
            }


            return new ElasticClient(setting);
        }

        ///// <summary>
        ///// 如果同名索引不存在则创建索引
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="client">ElasticClient实例</param>
        ///// <param name="indexName">要创建的索引名称</param>
        ///// <param name="numberOfReplicas">默认副本数量，如果是单实例，注意改成0</param>
        ///// <param name="numberOfShards">默认分片数量</param>
        ///// <returns></returns>
        //public static bool CreateIndex<T>(this ElasticClient client, string indexName = "", int numberOfReplicas = 1, int numberOfShards = 5) where T : class
        //{
        //    if (client.IndexExists(indexName).Exists) return false;

        //    var indexState = new IndexState
        //    {
        //        Settings = new IndexSettings
        //        {
        //            NumberOfReplicas = numberOfReplicas, //副本数
        //            NumberOfShards = numberOfShards //分片数
        //        }
        //    };

        //    if (string.IsNullOrWhiteSpace(indexName))
        //    {
        //        indexName = typeof(T).Name.ToLower();
        //    }

        //    var result = client.CreateIndex<T>(indexName, c => c.InitializeUsing(indexState).Mappings(ms => ms.Map<T>(m => m.AutoMap())));
        //    return result.Acknowledged;
        //}

        /// <summary>
        /// 创建文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool Create<T>(this ElasticClient client, T obj) where T : class
        {
            CreateRequest<T> log = new CreateRequest<T>(Guid.NewGuid());

            log.Document = obj;

            CreateResponse result = client.Create<T>(log);

            return result.IsValid;
        }

        /// <summary>
        /// 删除文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static bool Delete<T>(this ElasticClient client, string id) where T : class
        {
            DeleteResponse result = client.Delete<T>(new DocumentPath<T>(id));

            return result.IsValid;
        }

        /// <summary>
        /// 更新文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="id"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool Update<T>(this ElasticClient client, string id, T obj) where T : class
        {
            UpdateRequest<T, T> data = new UpdateRequest<T, T>(Guid.NewGuid());

            UpdateResponse<T> result = client.Update<T>(new DocumentPath<T>(id), f => f.Doc(obj));
            CheckValid<T>(result);

            return result.IsValid;
        }

        /// <summary>
        /// 获取文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static T Get<T>(this ElasticClient client, string id) where T : class
        {
            GetResponse<T> data = client.Get<T>(id);
            CheckValid<T>(data);

            return data.Source;
            //var tweet = JsonConvert.SerializeObject(stu);
        }

        /// <summary>
        /// 获取文档list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="ids"></param>
        /// <returns></returns>
        public static List<T> GetList<T>(this ElasticClient client, List<string> ids) where T : class
        {
            var data = client.Search<T>(f => f.Query(q => q.Ids(id => id.Values(ids))));
            CheckValid<T>(data);

            return data.Documents.ToList();
        }

        /// <summary>
        /// 获取分页文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="client"></param>
        /// <param name="query"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static PageModel<T> GetPageList<T>(this ElasticClient client, Func<QueryContainerDescriptor<T>, QueryContainer> query, int pageIndex = 1, int pageSize = 10) where T : class
        {
            if (pageIndex <= 0 || pageSize <= 0)
            {
                throw new Exception("ErrorPageInfo");
            }
            //, 
            var data = client.Search<T>(s => s
           .From(pageIndex - 1)
           .Size(pageSize)
           .Query(query));

            // var stus = client.Search<T>(s => s
            //.From(0)
            //.Size(10)
            //.Query(q =>
            //        q.Term(t => t.name, "jim")

            //        || q.Match(mq => mq.Field(f => f.age).Query("1"))
            //    )
            // );
            CheckValid<T>(data);

            return new PageModel<T>
            {
                Data= data.Documents.ToList(),
                TotalCount= data.HitsMetadata.Total.Value
            };
        }

        private static void CheckValid<T>(IResponse response) where T : class
        {
            if (!response.IsValid)
            {
                throw response.OriginalException;
            }
        }



        /// <summary>
        /// 返回一个正序排列的委托
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="field"></param>
        /// <returns></returns>
        public static Func<SortDescriptor<T>, SortDescriptor<T>> Sort<T>(string field) where T : class
        {
            return sd => sd.Ascending(field);
        }

        public static Func<SortDescriptor<T>, SortDescriptor<T>> Sort<T>(Expression<Func<T, object>> field) where T : class
        {
            return sd => sd.Ascending(field);
        }

        /// <summary>
        /// 返回一个倒序排列的委托
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="field"></param>
        /// <returns></returns>
        public static Func<SortDescriptor<T>, SortDescriptor<T>> SortDesc<T>(string field) where T : class
        {
            return sd => sd.Descending(field);
        }

        public static Func<SortDescriptor<T>, SortDescriptor<T>> SortDesc<T>(Expression<Func<T, object>> field) where T : class
        {
            return sd => sd.Descending(field);
        }

        /// <summary>
        /// 返回一个Must条件集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static List<Func<QueryContainerDescriptor<T>, QueryContainer>> Must<T>() where T : class
        {
            return new List<Func<QueryContainerDescriptor<T>, QueryContainer>>();
        }

        public static List<Func<QueryContainerDescriptor<T>, QueryContainer>> Should<T>() where T : class
        {
            return new List<Func<QueryContainerDescriptor<T>, QueryContainer>>();
        }

        /// <summary>
        /// 添加Match子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要查询的关键字</param>
        /// <param name="boost"></param>
        public static void AddMatch<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            string value, double? boost = null) where T : class
        {
            musts.Add(d => d.Match(mq => mq.Field(field).Query(value).Boost(boost)));
        }

        public static void AddMatch<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, string value) where T : class
        {
            musts.Add(d => d.Match(mq => mq.Field(field).Query(value)));
        }

        /// <summary>
        /// 添加MultiMatch子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="fields">要查询的列</param>
        /// <param name="value">要查询的关键字</param>
        public static void AddMultiMatch<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            string[] fields, string value) where T : class
        {
            musts.Add(d => d.MultiMatch(mq => mq.Fields(fields).Query(value)));
        }

        /// <summary>
        /// 添加MultiMatch子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="fields">例如：f=>new [] {f.xxx, f.xxx}</param>
        /// <param name="value">要查询的关键字</param>
        public static void AddMultiMatch<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> fields, string value) where T : class
        {
            musts.Add(d => d.MultiMatch(mq => mq.Fields(fields).Query(value)));
        }

        /// <summary>
        /// 添加大于子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要比较的值</param>
        public static void AddGreaterThan<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).GreaterThan(value)));
        }

        public static void AddGreaterThan<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).GreaterThan(value)));
        }

        /// <summary>
        /// 添加大于等于子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要比较的值</param>
        public static void AddGreaterThanEqual<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).GreaterThanOrEquals(value)));
        }

        public static void AddGreaterThanEqual<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).GreaterThanOrEquals(value)));
        }

        /// <summary>
        /// 添加小于子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要比较的值</param>
        public static void AddLessThan<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).LessThan(value)));
        }

        public static void AddLessThan<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).LessThan(value)));
        }

        /// <summary>
        /// 添加小于等于子句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要比较的值</param>
        public static void AddLessThanEqual<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).LessThanOrEquals(value)));
        }

        public static void AddLessThanEqual<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, double value) where T : class
        {
            musts.Add(d => d.Range(mq => mq.Field(field).LessThanOrEquals(value)));
        }

        /// <summary>
        /// 添加一个Term，一个列一个值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field">要查询的列</param>
        /// <param name="value">要比较的值</param>
        public static void AddTerm<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            object value) where T : class
        {
            musts.Add(d => d.Term(field, value));
        }

        public static void AddTerm<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, object value) where T : class
        {
            musts.Add(d => d.Term(field, value));
        }

        /// <summary>
        /// 添加一个Terms，一个列多个值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="musts"></param>
        /// <param name="field"></param>
        /// <param name="values"></param>
        public static void AddTerms<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts, string field,
            object[] values) where T : class
        {
            musts.Add(d => d.Terms(tq => tq.Field(field).Terms(values)));
        }

        public static void AddTerms<T>(this List<Func<QueryContainerDescriptor<T>, QueryContainer>> musts,
            Expression<Func<T, object>> field, object[] values) where T : class
        {
            musts.Add(d => d.Terms(tq => tq.Field(field).Terms(values)));
        }
    }