A common problem that we are faced when we have deployed our applications is improve the performance of a page or feature.
In my case for example I had a field where I could search and select a city, so the starting elements were a lot and the search was quite slow; I wanted a better user experience.
We can solve performance problems like these with the help of a cache or a full-text search.
I have chosen the last one and elastic search as full-text engine, so I’ll describe the steps that I followed to configure and use it in my application.
Installation
The first step is install the elastic search server, that you can download here.
Once installed we have to start it by executing the following executable:
<Installation path>\bin\elasticsearch.bat
This is the server log:
The server will take care to index the content that we will pass to it; in order to do that we need a client to use in our application; in my case the application was .NET and I used NEST.
NEST
As said above, NEST is an elastic search high level client for .NET applications.
The first step is install it in the application with nuget:
Install-package NEST
And in the package.config we’ll have:
Now we have all the necessary tools and we can develop the code for the search feature.
Client
We define a client class that has one responsability, that is setup the url and the default index of the client, and that instantiate it:
public class ElasticSearchClient
{
privatereadonlyIElasticClient _client;
publicElasticSearchClient(IElasticClient client)
{
_client = client;
}
publicElasticSearchClient(string uri, string indexName) : this(CreateElasticClient(uri, indexName)) {}
publicIElasticClientGetClient()
{
return_client;
}
privatestaticElasticClientCreateElasticClient(string uri, string indexName)
{
var node = newUri(uri);
var setting = newConnectionSettings(node);
setting.DefaultIndex(indexName);
returnnewElasticClient(setting);
}
}
Once instantiated, the class returns a new instance of the client; we can register it in the startup class of the application with autofac:
public partial class Startup
{
publicvoidConfiguration(IAppBuilder app)
{
var builder = newContainerBuilder();
builder.Register(c => newElasticSearchClient("http://localhost:9200", "cities"))
.AsSelf()
.SingleInstance();
...
}
}
Service base class
A service that uses an elasticsearch index should be able to do some basic operations, that concerns the logics of the full-text indexes.
We have to deal with the initialize a specific index, populate the index with the contents, obviously performs a search on the index with specific parameters.
So, we have to define an interface like this:
internal interface IElasticSearchService<T> where T : class
{
voidInit();
voidCheckIndex();
voidBulkInsert(List<T> objects);
IEnumerable<T> Search(string query);
}
I like to separate the init method, that create the index, from the checkindex method, that check if the index already exists.
Now we can implement the basic service:
public class ElasticSearchService<T> : IElasticSearchService<T> where T : class
{
protectedreadonlyContext Db = newContext();
protectedreadonlyElasticSearchClient ElasticSearchClient;
protectedreadonlystring IndexName;
publicElasticSearchService(ElasticSearchClient elasticSearchClient, string indexName)
{
ElasticSearchClient = elasticSearchClient;
IndexName = indexName;
}
publicvirtualvoidInit()
{
CheckIndex();
BulkInsert(Db.Set<T>().ToList());
}
publicvoidCheckIndex()
{
if (IndexExist()) return;
var response = CreateIndex();
if (!response.IsValid)
{
thrownewException(response.ServerError.ToString(), response.OriginalException);
}
}
publicvoidBulkInsert(List<T> objects)
{
var response = ElasticSearchClient.GetClient().IndexMany(objects, IndexName);
if (!response.IsValid)
{
thrownewException(response.ServerError.ToString(), response.OriginalException);
}
}
publicvirtualIEnumerable<T> Search(string query)
{
var results = ElasticSearchClient.GetClient().Search<T>(c => c.From(0).Size(10).Query(q => q.Prefix("_all", query)));
returnresults.Documents;
}
protectedvirtualIResponseCreateIndex()
{
var indexDescriptor = newCreateIndexDescriptor(IndexName).Mappings(ms => ms.Map<T>(m => m.AutoMap()));
returnElasticSearchClient.GetClient().CreateIndex(indexDescriptor);
}
protectedboolIndexExist()
{
returnElasticSearchClient.GetClient().IndexExists(IndexName).Exists;
}
}
The constructor accept the client and the index name.
We define a virtual init method, that check if the index exists and do a bulkinsert of a list of object; the method is virtual, we think that a derived service could override the method.
This bulkinsert method leverage the client to index the object list and the search method implements a basic search, that searchs in all the fields of the objects by using the special field _all, which contains the concatenate values of all fields.
The method returns the first 10 elements.
Createindex create a specific index with automap option, that infers the elasticsearch fields datatypes from the POCO object that we pass to it; it’s protected, so the derived class could use it.
IndexExists check if an index exists and it can be used from the derived class as well.
Service
Now we can implement a specific service, that inherits from ElasticSearchService class.
In this example I need to search in a list of cities and related districts, so I need to override the CreateIndex method like this:
public sealed class CitiesService : ElasticSearchService<City>
{
publicCitiesService(ElasticSearchClient elasticSearchClient, string indexName): base(elasticSearchClient, indexName) {}
protectedoverrideIResponseCreateIndex()
{
var indexDescriptor = newCreateIndexDescriptor(IndexName).Mappings(
ms => ms.Map<City>(m => m.AutoMap().Properties(ps =>
ps.Nested<District>(n => n
.Name(nn => nn.District)
.AutoMap()))));
returnElasticSearchClient.GetClient().CreateIndex(indexDescriptor);
}
publicoverrideIEnumerable<City> Search(string query)
{
var results = ElasticSearchClient.GetClient().Search<City>(c => c.From(0).Size(10).Query(q => q.Prefix(p => p.Name, query) || q.Term("district.name", query)));
returnresults.Documents.OrderBy(d => d.Name);
}
}
What I need to do is automap the city object and the district, that is a closely related entity of the city; so I have to map the District property as nested with the automap option as well.
Thus I will able to search for all the properties of the city and the district.
The other method that I override is the Search method; I search partially in the name of the city (Prefix) and the specific term in the district name (Term) and I returns the first 10 elements.
Now I have to register the service with autofac:
public partial class Startup
{
public void Configuration(IAppBuilder app)
{
var builder = newContainerBuilder();
builder.Register(c => newElasticSearchClient("http://localhost:9200", "cities"))
.AsSelf()
.SingleInstance();
builder.Register(c => newCitiesService(c.Resolve<ElasticSearchClient>(), "cities"))
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance();
...
}
}
The last step is initialize the full text index of my service:
public partial class Startup
{
publicvoidConfiguration(IAppBuilder app)
{
var builder = newContainerBuilder();
builder.Register(c => newElasticSearchClient("http://localhost:9200", "cities"))
.AsSelf()
.SingleInstance();
builder.Register(c => newCitiesService(c.Resolve<ElasticSearchClient>(), "cities"))
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance();
...
InitElasticSearchServices(containerBuilder);
}
privatestaticvoidInitElasticSearchServices(IContainer containerBuilder)
{
var citiesServices = containerBuilder.Resolve<CitiesService>();
citiesServices.Init();
}
}
I make a new instance of the service and call the Init method of the ElasticSearchService that we have seen above.
This method will create and populate the index.
Web API
Now I can use the service in my Web API, like this:
public class CitiesController : ApiController
{
privatereadonlyCitiesService _elasticSearchService;
publicCitiesController(CitiesService elasticSearchService)
{
_elasticSearchService = elasticSearchService;
}
// GET: api/Cities
publicIEnumerable<City> GetCities(string query)
{
return_elasticSearchService.Search(query);
}
protectedoverridevoidDispose(bool disposing)
{
base.Dispose(disposing);
}
}
You can find the source code of this topic here.
Mirko Maggioni 
Leave a Reply