SearchExtensions is a library of IQueryable and IEnumerable extension methods to perform searching. More information on these packages and it's use can be found by, visiting my blog.
This project is represents the source code for the following 3 nuget packages:
- NinjaNye.SearchExtensions - A fluent api for performing complex searches across
IEnumerableandIQueryablecollections. - NinjaNye.SearchExtensions.Levenshtein - This package specialises in performing Levenshtein searches across
IEnumerablecollections. - NinjaNye.SearchExtensions.Soundex - This package specialises in performing Soundex searches across
IEnumerablecollections.
- Soundex support migrated to dedicated nuget package
- Levenshtein support migrated to dedicated nuget package
- Constructed expressions can now be pulled out and re-used.
As of version 3.0 Soundex and Levenshtein support has been migrated into their own respective packages (above). All functionality still remains. If you are currently using Levensthein or Soundex functionlity in version 2.2 or lower, please upgrade to you the dedicated package.
The IQueryable extension methods build expression trees based on your command chain and then sends this request to the data provider when required. This means that your data provider is restricting the records that are brought into memory instead of having all records brought into, and filtered, in memory.
Search methods available to IQueryable data are:
Containing- target property contains search term or termsIsEqual- target property equals search term or termsStartsWith- target property starts with search term or terms
Search for a single search term within a single property
var result = queryableData.Search(x => x.Property1)
.Containing("searchTerm");
Search for a single search term within multiple properties
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.Containing("searchTerm");
Search for multiple search terms within a single property
var result = queryableData.Search(x => x.Property1)
.Containing("search", "term");
Search for multiple search terms within multiple properties
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.Containing("searchTerm1",
"searchTerm2",
"searchTerm3");
Search where a single property contains a single search term
AND a another property contains a single search term
var result = queryableData.Search(x => x.Property1)
.Containing("searchTerm1")
.Search(x => x.Property1)
.Containing("searchTerm2");
Search where a single search term exists within in Property1 OR Property2
AND single search term exists within in Property3 OR Property4
var result = queryableData.Search(x => x.Property1, x => x.Property2)
.Containing("searchTerm")
.Search(x => x.Property3, x => x.Property4)
.Containing("searchTerm");
Search where a single search term exists in Property1 OR Property2
AND any of the multiple search terms exist within a single property
var result = queryableData.Search(x => x.Property1, x => x.Property2)
.Containing("searchTerm")
.Search(x => x.Property3)
.Containing("another", "term");
Search where a single property equals a single search term
var result = queryableData.Search(x => x.Property1)
.IsEqual("searchTerm");
Search where any one of multiple properties is equal to a single search term
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.IsEqual("searchTerm");
Search where a single property is equal to any one of multiple search terms
var result = queryableData.Search(x => x.Property1)
.IsEqual("search", "term");
Search where any one of multiple properties is equal to any one of multiple search terms
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.IsEqual("searchTerm1",
"searchTerm2",
"searchTerm3");
Search where a single property starts with a single search term
var result = queryableData.Search(x => x.Property1)
.StartsWith("searchTerm");
Search where any one of multiple properties starts with to a single search term
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.StartsWith("searchTerm");
Search where a single property starts with any one of multiple search terms
var result = queryableData.Search(x => x.Property1)
.StartsWith("search", "term");
Search where any one of multiple properties starts with any one of multiple search terms
var result = queryableData.Search(x => x.Property1,
x => x.Property2,
x => x.Property3)
.StartsWith("searchTerm1",
"searchTerm2",
"searchTerm3");
With the latest version of SearchExtensions you can also combine search actions. For instance
Search where a single property starts with a single search term AND containing a single search term
var result = queryableData.Search(x => x.Property1)
.StartsWith("abc")
.Containing("mno");
The ability to pass multiple search terms to any of the action methods still remains:
var result = queryableData.Search(x => x.Property1, x => x.Property2)
// that starts with "abc" OR "ninja"
.StartsWith("abc", "ninja")
// and contains "xyz" OR "extensions"
.Containing("xyz", "extensions")
SearchExtensions has also been extended to support IEnumerable collections.
This means you can now perform all of the above searches on in memory collections should you need to.
Currently IEnumerable searching has more features available to it than IQueryable, namely EndsWith and SetCulture
SetCulture- Sets the string comparison culture with which to perform searchesContaining- target property contains search term or termsIsEqual- target property equals search term or termsStartsWith- target property starts with search term or termsEndsWith- target property ends with search term or terms
The important thing to remember when performing an in memory search is to set the culture to the type of string comparison you wish to perform. If SetCulture is not specified, StringComparison.CurrentCulture is used.
These methods are identical to that of the IQueryable methods.
var result = enumerableData.Search(x => x.Property1)
.SetCulture(StringComparison.OrdinalIgnoreCase) // Set culture for comparison
.StartsWith("abc")
.EndsWith("xyz")
.Containing("mno");
It is also possible to switch the StringComparison culture context multiple times
var result = enumerableData.Search(x => x.Property1)
.SetCulture(StringComparison.OrdinalIgnoreCase)
.StartsWith("abc") // Uses OrdinalIgnoreCase
.SetCulture(StringComparison.Ordinal)
.EndsWith("xyz") // Uses Ordinal
.SetCulture(StringComparison.CurrentCulture)
.Containing("mno"); //Uses CurrentCulture
Another feature of the fluent api across both IQueryable and IEnumerable collections is the ToRanked() method.
As well as returning the matched items, a Ranked Search also returns a hit count for each item in the form of an IRanked<T> result. This enables you to order by hit count to retrieve the most relevant search results.
An IRanked<T> result is simply defined as follows:
public interface IRanked<out T>
{
int Hits { get; }
T Item { get; }
}
This is returned using the ToRanked() method:
RankedSearch for a single search term within a single property
var result = queryableData.Search(x => x.Property1)
.Containing("searchTerm")
.ToRanked();
RankedSearch for a single search term within multiple properties
var result = queryableData.Search(x => x.Property1, x => x.Property2, x => x.Property3)
.Containing("searchTerm")
.ToRanked();
RankedSearch for multiple search terms within a single property
var result = queryableData.Search(x => x.Property1)
.Containing("searchTerm1", "searchTerm2", "searchTerm3")
.ToRanked();
RankedSearch for multiple search terms within multiple properties
var result = queryableData.Search(x => x.Property1, x => x.Property2)
.Containing("searchTerm1", "searchTerm2", "searchTerm3")
.ToRanked();
Using ranked search you can now easily order your search results by the most relevant. This following example assumes we have a list of User which has FirstName, LastName and MiddleName string properties. In this example we want to match on those with "John" in their name and retrieve the top 10 results.
var result = context.Users.Search(x => x.FirstName, x => x.LastName, x.MiddleName)
.Containing("John")
.ToRanked()
.OrderByDescending(r => r.Hits) // Order by Hits property of IRanked<User>
.Take(10);
We can also mix it up with the other fluent API methods
var result = context.Users.Search(x => x.FirstName, x => x.LastName, x => x.MiddleName)
.StartsWith("john")
.Containing("nye")
.ToRanked()
.OrderByDescending(r => r.Hits) // Order by Hits property of IRanked<User>
.Take(10);
Be aware that the ToRanked() method uses the search terms of the Containing() method combined with the properties to search to build its hit count. The fluent ToRanked() method also means the old RankedSearch method is now depreciated. It still lives in the code but will soon be removed so please update your code to use the fluent api.
NinjaNye.SearchExtensions.Soundex supports converting and searching for words that sound like a given word.
Returning records that 'sound like' "test" using the Soundex algorythm:
Search where a single property sounds like a single search term
var result = data.SoundexOf(x => x.Property1).Matching("test")
Search where a any of multiple properties sounds like a single search term
var result = data.SoundexOf(x => x.Property1, x => x.PropertyTwo)
.Matching("test")
Search where a single property sounds like any one of multiple search terms
var result = data.SoundexOf(x => x.Property1).Matching("test", "another")
Search where a any of multiple properties sounds like any of multiple search terms
var result = data.SoundexOf(x => x.Property1, x => x.PropertyTwo)
.Matching("test", "another")
All the abouve soundex axamples can be performed using the Reverse Soundex algorythm.
Simply substitute in the ReverseSoundexOf() method. For example:
Search where a single property sounds like a single search term
var result = data.ReverseSoundexOf(x => x.Property1).Matching("test")
Search where a any of multiple properties sounds like a single search term
var result = data.ReverseSoundexOf(x => x.Property1, x => x.PropertyTwo)
.Matching("test")
The above
SoundexOfandReverseSoundexOfmethods can also be applied toIQueryabledata. ForIQueryablewe reduce the amount of records returned from the data source as much as possible but be aware that the soundex searching is performed on the in memory collection.
For more information about the Soundex search functionality, soundex search performance, and how it has been integrated with IQueryable, please visit http://jnye.co/soundex
If you have any new feature requests, questions, or comments, please get in touch, either, via my website, twitter or preferrably raise an issue in this github repository.