同义词在C#elasticSearch客户端中不起作用？

我正在开发一个简单的winformsApp，它将使用elasticSearch从数据库中进行搜索。当我的elasticSearchClient.cs文件与winformsApp项目位于同一项目中时，搜索和同义词标记过滤器工作正常。但是，当我创建了一个包含相同elasticSearchClient.cs文件的单独项目时，同义词标记过滤器停止工作。不过搜索仍在顺利进行

我将在下面附上winformsApp代码和elasticSearch客户端代码。我的问题是，当winformsapp和elasticsearch客户端位于两个不同的项目中时，如何让同义词工作？或者我可以采取什么顺序调试步骤来找出错误的确切位置？谢谢

elasticSearchClient.cs文件：

using Elasticsearch.Net;
using Nest;
using Newtonsoft.Json;
using System;
using System.Configuration;
using System.Threading.Tasks;
using Nest.JsonNetSerializer;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json.Serialization;
using SynonymSearch.ElasticSearch;


namespace NESTClient.ElasticSearch
{
    public class ElasticSearchClient : ElasticSearchClientBase
    {
        public const string synonymsindexname = "synonyms";
        public const string WORDNETSYNONYMFILEPATH = "synonyms/WNprolog-3.0/prolog/wn_s.pl";

        #region Constructors
        public ElasticSearchClient()
            : base()
        {
            ConnectionSettings.DefaultMappingFor<ClinicalCode>(m => m
            );
        }
        #endregion

        #region Overrides

        public override string Username
        {
            get
            {

                return ConfigurationManager.AppSettings["ElasticSearchUsername"];

            }
        }


        public override string Password
        {
            get
            {

                return ConfigurationManager.AppSettings["ElasticSearchPassword"];
            }
        }


        public override string ElasticSearchUrl
        {
            get
            {

                string elasticSearchUrl = ConfigurationManager.AppSettings["ElasticSearchUrl"];
                if (string.IsNullOrEmpty(elasticSearchUrl))

                    return "http://localhost.:9200"; 
                else
                    return elasticSearchUrl;
            }
        }

        public override ConnectionSettings InitializeConnectionSettings(string elasticSearchUrl)
        {
            var pool = new SingleNodeConnectionPool(new Uri(elasticSearchUrl));
            var connection = new HttpConnection();

            var connectionSettings = new ConnectionSettings(
                pool,
                connection: connection,

                sourceSerializer: (builtin, settings) => new NestJsonNetSerializer(builtin, settings)

            );


            if (string.IsNullOrEmpty(Username) == false && string.IsNullOrEmpty(Password))
                connectionSettings = connectionSettings.BasicAuthentication(Username, Password);
            return connectionSettings;
        }
        #endregion

        #region Index Creation(s)

        public void CreatesynonymsIndex()
        {
            Task task = CreatesynonymsIndexAsync();
            task.Wait();
        }


        public async Task CreatesynonymsIndexAsync()
        {

            if (Client.IndexExists(synonymsindexname).Exists)
            {
                var deleteIndexTask = Client.DeleteIndexAsync(synonymsindexname);
                await deleteIndexTask;
                if (deleteIndexTask.Result.IsValid == false)
                {
                    var serverError = deleteIndexTask.Result.ServerError;
                    throw new Exception(string.Format("{0}: {1}", serverError.Status, serverError.Error));
                }
            }


            **var createIndexTask = Client.CreateIndexAsync(synonymsindexname, i => i
                .Settings(s => s
                    .Analysis(a => a
                         .TokenFilters(t => t



                            .Stop("my_english_stop", st => st
                                .IgnoreCase()
                                .StopWords("_english_")
                            )

                            .Synonym("my_synonyms", syn => syn

                                    // .Format(SynonymFormat.WordNet)
                                    // .SynonymsPath(WORDNETSYNONYMFILEPATH)

                                    .Tokenizer("lowercase")
                                    .Format(SynonymFormat.Solr)
                              //.Synonyms(
                               //   "cholera, colera"
                             //    "typhoid, tyfoid",
                             //    "shigellosis, shigelosys abc"

                             // )
                             .SynonymsPath("synonyms/solrsynonyms.txt")

                            )
                        )
                        .Analyzers(aa => aa



                            .Standard("standard_english", sa => sa
                                .StopWords("_english_")
                            )

                           .Custom("my_synonym2", c => c


                              .Tokenizer("standard")



                              .Filters("lowercase", "my_synonyms", "test", "standard", "my_english_stop")
                           )

                        )

                    )
                )

                .Mappings(m => m
                    .Map<ClinicalCode>(c => c

                        .AutoMap()

                        .Properties(p => p

                            .Keyword(k => k
                                .Name(n => n.ICDCode)

                            )
                            .Text(t => t
                                .Name(n => n.ShortDescription)
                                .Name(n => n.LongDescription)
                                .Analyzer("my_synonym2")

                            )
                            .Text(t => t
                                .Name(n => n.ShortDescription)
                                .Name(n => n.LongDescription)
                                .Analyzer("standard_english")
                            )
                            .Text(t => t
                                .Name(n => n.ShortDescription)
                                .Name(n => n.LongDescription)
                                .Analyzer("english")
                            )
                            .Text(t => t
                                .Name(n => n.ShortDescription)
                                .Name(n => n.LongDescription)
                                .Analyzer("simple")
                            )
                            .Completion(com => com
                                .Name(n => n.ShortDescription)
                            )
                        )
                    )
                ) 
            );**



            await createIndexTask;
            var result = createIndexTask.Result;
            if (createIndexTask.Result.IsValid == false)
            {
                var serverError = createIndexTask.Result.ServerError;
                throw new Exception(string.Format("{0}: {1}", serverError.Status, serverError.Error));
            }
        }
        #endregion
    }


    public class NestJsonNetSerializer : ConnectionSettingsAwareSerializerBase 
    {
        public NestJsonNetSerializer(IElasticsearchSerializer builtinSerializer, IConnectionSettingsValues connectionSettings)
            : base(builtinSerializer, connectionSettings) { }

        protected override IEnumerable<JsonConverter> CreateJsonConverters() =>
            Enumerable.Empty<JsonConverter>();

        protected override JsonSerializerSettings CreateJsonSerializerSettings() =>
            new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Include,
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };
    }

}

使用Elasticsearch.Net；
利用鸟巢；
使用Newtonsoft.Json；
使用制度；
使用系统配置；
使用System.Threading.Tasks；
使用Nest.JsonNetSerializer；
使用System.Collections.Generic；
使用System.Linq；
使用Newtonsoft.Json.Serialization；
使用同义词搜索。弹性搜索；
命名空间NESTClient.ElasticSearch
{
公共类ElasticSearchClient:ElasticSearchClientBase
{
public const字符串同义词index name=“同义词”；
public const string wordnetsynnonymfilepath=“同义词/WNprolog-3.0/prolog/wn_.pl”；
#区域构造函数
公共ElasticSearchClient（）
：base（）
{
ConnectionSettings.DefaultMappingFor（m=>m
);
}
#端区
#区域覆盖
公共重写字符串用户名
{
得到
{
返回ConfigurationManager.AppSettings[“ElasticSearchUsername”]；
}
}
公共重写字符串密码
{
得到
{
返回ConfigurationManager.AppSettings[“ElasticSearchPassword”]；
}
}
公共重写字符串ElasticSearchUrl
{
得到
{
字符串elasticSearchUrl=ConfigurationManager.AppSettings[“elasticSearchUrl”]；
if（string.IsNullOrEmpty（elasticSearchUrl））
返回“http://localhost.:9200"; 
其他的
返回elasticSearchUrl；
}
}
公共覆盖连接设置初始化连接设置（字符串elasticSearchUrl）
{
var pool=newsinglenodeconnectionpool（newuri（elasticSearchUrl））；
var connection=新的HttpConnection（）；
var connectionSettings=新的connectionSettings(
水塘
连接：连接，
sourceSerializer：（内置，设置）=>新的NestJsonNetSerializer（内置，设置）
);
if（string.IsNullOrEmpty（用户名）=false&&string.IsNullOrEmpty（密码））
connectionSettings=connectionSettings.BasicAuthentication（用户名、密码）；
返回连接设置；
}
#端区
#创建区域索引
public void CreatesynonymsIndex（）
{
Task Task=CreatesynonymsIndexAsync（）；
task.Wait（）；
}
公共异步任务CreatesynonymsIndexAsync（）
{
if（Client.indexists（synonymsindexname.Exists）
{
var deleteIndexTask=Client.DeleteIndexAsync（同义词IndexName）；
等待删除索引任务；
if（deleteIndexTask.Result.IsValid==false）
{
var serverError=deleteIndexTask.Result.serverError；
抛出新异常（string.Format（“{0}:{1}”，serverError.Status，serverError.Error））；
}
}
**var createIndexTask=Client.CreateIndexAsync（同义词IndexName，i=>i
.Settings（s=>s
.分析（a=>a
.TokenFilters（t=>t
.停止（“我的英语停止”，st=>st
.IgnoreCase（）
.StopWords（“英语”）
)
.Synonym（“我的同义词”，syn=>syn
//.Format（同义词格式.WordNet）
//.SynonymsPath（WORDNETSYNONYMFILEPATH）
.Tokenizer（“小写”）
.Format（同义词格式.Solr）
//.同义词(
//霍乱、霍乱
//“伤寒，泰福”，
//志贺菌病
// )
.SynonymsPath（“synonyms/solrsynonyms.txt”）
)
)
.分析仪（aa=>aa
.Standard（“标准英语”，sa=>sa
.StopWords（“英语”）
)
.Custom（“my_同义词2”，c=>c
.Tokenizer（“标准”）
.Filters（“小写”、“我的同义词”、“测试”、“标准”、“我的英语停止”）
)
)
)
)
.Mappings（m=>m
.Map（c=>c
.AutoMap（）
.Properties（p=>p
.Keyword（k=>k
.Name（n=>n.ICDCode）
)
.Text（t=>t
.Name（n=>n.ShortDescription）
.Name（n=>n.LongDescription）
.Analyzer（“my_同义词2”）
)
.Text（t=>
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Nest;
using SynonymSearch.ElasticSearch;
using NESTClient.ElasticSearch;


namespace ServerWinforms
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            ElasticSearchClient searchClient = new ElasticSearchClient();

            PerformDeleteIndex();
            PerformCreateIndex();
            PerformSearchIndexing();

            PerformGettingAllItems();


        }

        private void button1_Click(object sender, EventArgs e)
        {

            string query = textBox1.Text;
            //MessageBox.Show("hola");


            ElasticSearchClient searchClient = new ElasticSearchClient();
            ISearchResponse<ClinicalCode> response = null;

            response = searchClient.Client.Search<ClinicalCode>(x => x  
                .Index(ElasticSearchClient.synonymsindexname)
                .Query(q => q               
                    .MultiMatch(mp => mp            
                        .Query(query)           
                       // .Fuzziness(Fuzziness.Auto) 
                        .Fields(fs => fs
                            .Field(f => f.ICDCode) 
                            .Field(f => f.ShortDescription) 
                            .Field(f => f.LongDescription)


                        )

                    )   
                )
                .Highlight(h => h 
                    .PreTags("<mark class='hit'>")
                    .PostTags("</mark>")
                    .Fields(fs => fs
                        .Field("*")
                        .RequireFieldMatch(false) 
                    )
                )
                .From(0)                
                .Size(30)               
            );

            if (response.IsValid == false) 
            {
                MessageBox.Show(response.DebugInformation);
            }
            else
            {
                StringBuilder sb = new StringBuilder();

                    IEnumerable<IHit<ClinicalCode>> synonymsHits = response.Hits.OrderBy(x => x.Source.ICDCode).ThenBy(x => x.Source.ShortDescription).ThenBy(x => x.Source.LongDescription);
                    foreach (IHit<ClinicalCode> synonymsHit in synonymsHits)
                    {

                        HighlightFieldDictionary highlightFieldDictionary = synonymsHit.Highlights;

                        if (highlightFieldDictionary.ContainsKey("ICDCode"))
                            sb.AppendLine(string.Format("ICDCode:       {0}", highlightFieldDictionary["ICDCode"].Highlights.First())); 
                        else
                            sb.AppendLine(string.Format("ICDCode:       {0}", synonymsHit.Source.ICDCode));

                        if (highlightFieldDictionary.ContainsKey("ShortDescription"))
                            sb.AppendLine(string.Format("ShortDescription:       {0}", highlightFieldDictionary["ShortDescription"].Highlights.First()));
                        else
                            sb.AppendLine(string.Format("ShortDescription:       {0}", synonymsHit.Source.ShortDescription));

                        if (highlightFieldDictionary.ContainsKey("LongDescription"))
                            sb.AppendLine(string.Format("LongDescription:       {0}", highlightFieldDictionary["LongDescription"].Highlights.First()));
                        else
                            sb.AppendLine(string.Format("LongDescription:       {0}", synonymsHit.Source.LongDescription));


                        sb.AppendLine();
                        sb.AppendLine();
                    }

                textBox2.Text = sb.ToString();




            }



        }
        private void label1_Click(object sender, EventArgs e)
        {


        }

        public static void PerformDeleteIndex()
        {

                ElasticSearchClient searchClient = new ElasticSearchClient();

                var deleteTask = searchClient.Client.DeleteIndexAsync(ElasticSearchClient.synonymsindexname);

        }

        public static void PerformCreateIndex()
        {       

                ElasticSearchClient searchClient = new ElasticSearchClient();

                var createTask = searchClient.CreatesynonymsIndexAsync();

        }

        public static void PerformSearchIndexing()
        {

                List<ClinicalCode> synonymslist = ClinicalCode.GetAllsynonymslist(); 

                ElasticSearchClient searchClient = new ElasticSearchClient();                

                int batchSize = 100; 
                int maxParallelExecution = 10; 
                IndexByChunkSettings chunkSettings = new IndexByChunkSettings(batchSize, maxParallelExecution);
                chunkSettings.Index = ElasticSearchClient.synonymsindexname;
                var synonymsIndexingTask = searchClient.Client.IndexManyByChunkAsync(synonymslist, chunkSettings);            

        }

        public static void PerformGettingAllItems()
        {


            ElasticSearchClient searchClient = new ElasticSearchClient();
            ISearchResponse<ClinicalCode> response = null;

            response = searchClient.Client.Search<ClinicalCode>(s => s
                .Index(ElasticSearchClient.synonymsindexname)
                .From(0)
                .Take(20)
            );                       
        }



    }
}