Searching in ASP.NET MVC Grid component

2 Apr 202524 minutes to read

The Syncfusion^® ASP.NET MVC Grid includes a powerful built-in searching feature that allows users to search for specific data within the grid. This feature enables efficient filtering of grid records based on user-defined search criteria, making it easier to locate and display relevant information. Whether you have a large dataset or simply need to find specific records quickly, the search feature provides a convenient solution.

To set the AllowSearching property to true to enable the searching feature in the grid.

To further enhance the search functionality, you can integrate a search text box directly into the grid’s toolbar. This allows users to enter search criteria conveniently within the grid interface. To add the search item to the grid’s toolbar, use the Toolbar property and add Search item.

CSHTML
search.cs
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
  col.Field("OrderID").HeaderText("Order ID").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Width("160").Add();
  col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
  col.Field("Freight").HeaderText("Freight").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
  col.Field("OrderDate").HeaderText("Order Date").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
}).Toolbar(new List<string>() { "Search" }).Render();
public IActionResult Index()
 {
    var orders = OrdersDetails.GetAllRecords();
    ViewBag.datasource = orders;            
    return View();
 }

The clear icon is shown in the Data Grid search text box when it is focused on search text or after typing the single character in the search text box. A single click of the clear icon clears the text in the search box as well as the search results in the Grid.

Initial search

By default, the search operation can be performed on the grid data after the grid renders. However, there might be scenarios where need to perform a search operation on the grid data during the initial rendering of the grid. In such cases, you can make use of the initial search feature provided by the grid.

To apply search at initial rendering, need to set the following properties in the SearchSettings object.

Property	Description
Fields	Specifies the `Fields` in which the search operation needs to be performed.
Operator	Specifies the `Operator` to be used for the search operation.
Key	Specifies the `Key` value to be searched.
IgnoreCase	`IgnoreCase` specifies whether the search operation needs to be case-sensitive or case-insensitive.
IgnoreAccent	`IgnoreAccent`property will ignore the diacritic characters or accents in the text during a search operation.

The following example demonstrates how to set an initial search in the grid using the SearchSettings property. The SearchSettings property is set with the following values:

Fields: CustomerID specifies that the search should be performed only in the ‘CustomerID’ field.
Operator: contains indicates that the search should find records that contain the specified search key.
Key: Ha is the initial search key that will be applied when the grid is rendered.
IgnoreCase: true makes the search case-insensitive.
IgnoreAccent: true will ignores diacritic characters or accents during the search operation.

CSHTML
initial-search.cs
@Html.EJS().Grid("Grid").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("Freight").HeaderText("Freight").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
    col.Field("OrderDate").HeaderText("Order Date").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
}).SearchSettings(search => { search.Fields(new string[] { "CustomerID" }).Key("Ha").Operator("contains").IgnoreCase(true); }).Toolbar(new List<string>() { "Search" }).Render()
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

By default, grid searches all the bound column values. However, you can customize this behavior by definining the SearchSettings.Fields property.

Search operators

Search operators are symbols or keywords used to define the type of comparison or condition applied during a search operation. They help specify how the search key should match the data being searched. The SearchSettings.Operator property can be used to define the search operator in the grid.

By default, the SearchSettings.Operator is set to contains, which returns the values contains the search key. The following operators are supported in searching:

Operator	Description
startswith	Checks whether a value begins with the specified value.
endswith	Checks whether a value ends with the specified value.
contains	Checks whether a value contains with the specified value.
wildcard	Processes one or more search patterns using the *““** symbol, returning values that match the given patterns.
like	Processes a single search pattern using the ”%” symbol, retrieving values that match the specified pattern.
equal	Checks whether a value equal to the specified value.
notequal	Checks whether a value not equal to the specified value.

These operators provide flexibility in defining the search behavior and allow you to perform different types of comparisons based on your requirements.

The following example demonstrates how to set the SearchSettings.Operator property based on changing the dropdown value using the Change event of the DropDownList component.

CSHTML
Html.cs
@{
  ViewBag.dropdownData = new string[] { "contains", "startswith", "endswith","wildcard","like","equal","notequal"  };
}
<div style="display: flex">
	<label style="padding: 7px 10px 26px 0"> Change the search operators: </label>
	<span style="height:fit-content">
		@Html.EJS().DropDownList("search").Width("180px").Index(0).DataSource(@ViewBag.dropdownData).Change("change").Render()
	</span>
</div>
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("ShipName").HeaderText("Ship Name").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
    col.Field("ShipCountry").HeaderText("Ship Country").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
}).SearchSettings(search => { search.Operator("contains"); }).Toolbar(new List<string>() { "Search" }).Render()
<script>
	function change(args) {
		var grid = document.getElementById("Search").ej2_instances[0];
		grid.searchSettings.operator = args.value;
	}
</script>
public ActionResult Index()
{
  ViewBag.datasource = OrdersDetails.GetAllRecords();       
  return View();
}

Search by external button

The Syncfusion^® Grid component allows you to perform searches programmatically, enabling you to search for records using an external button instead of relying solely on the built-in search bar. This feature provides flexibility and allows for custom search implementations within your application. To search for records using an external button, you can utilize the search method provided by the Grid component.

The search method allows you to perform a search operation based on a search key or criteria. The following example demonstrates how to implement search by an external button using the following steps:

Add a button element outside of the grid component.
Attach a click event handler to the button.
Inside the event handler, get the reference of the grid component.
Invoke the search method of the grid by passing the search key as a parameter.

CSHTML
external-btn.cs
<div style="padding:0px 0px 20px 0px">
    @Html.EJS().TextBox("searchInput").Placeholder("Search text").Width("220px").Render()
    @Html.EJS().Button("SearchButton").Content("Search").CssClass("custom").Render()
</div>
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("Freight").HeaderText("Freight").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
    col.Field("OrderDate").HeaderText("Order Date").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
}).Render()
<script>
    document.getElementById('SearchButton').addEventListener('click', () => {
        var gridObj = document.getElementById("Search").ej2_instances[0];
        const searchText = document.getElementById("searchInput").ej2_instances[0].value;
        gridObj.search(searchText);
    });
</script>
<style>
    .custom {
        margin-left: 20px;
    }
</style>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

Search specific columns

By default, the search functionality searches all visible columns. However, if you want to search only specific columns, you can define the specific column’s field names in the SearchSettings.Fields property. This allows you to narrow down the search to a targeted set of columns, which is particularly useful when dealing with large datasets or grids with numerous columns.

The following example demonstrates how to search specific columns such as CustomerID, Freight, and ShipCity by using the SearchSettings.Fields property.

CSHTML
search-a-column.cs
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("ShipName").HeaderText("Ship Name").Width("170").Add();
    col.Field("ShipCity").HeaderText("Ship City").Width("140").Add();
}).SearchSettings(search => { search.Fields(new string[] { "CustomerID", "ShipCity", "ShipName" }); }).Toolbar(new List<string>() { "Search" }).Render()
public IActionResult Index()
 {
   var orders = OrderDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

Search on each key stroke

The search on each keystroke feature in Syncfusion^® Grid enables you to perform real-time searching of grid data as they type in the search text box. This functionality provides a seamless and interactive searching experience, allowing you to see the search results dynamically updating in real time as they enter each keystroke in the search box

To achieve this, you need to bind the keyup event to the search input element inside the Created event of the grid component.

In the following example, the Created event is bound to the grid component, and inside the event handler, the keyup event is bound to the search input element. Whenever the keyup event is triggered, the current search string is obtained from the search input element, and the search method is invoked on the grid instance with the current search string as a parameter. This allows the search results to be displayed in real-time as you type in the search box.

CSHTML
search-each-key.cs
@Html.EJS().Grid("Grid").DataSource((IEnumerable<object>)ViewBag.datasource).Height(400).Width("100%").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("ShipName").HeaderText("Ship Name").Width("170").Add();
    col.Field("ShipCity").HeaderText("Ship City").Width("140").Add();
}).Created("created").Toolbar(new List<string>() { "Search" }).Render()
<script>
    function created() {
        var grid = document.getElementById("Grid").ej2_instances[0];
        document.getElementById(grid.element.id + "_searchbar").addEventListener('keyup', () => {
            grid.search(event.target.value)
        });
    }
</script>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

Search on each key stroke approach may affect the performance of the application when dealing with a large number of records.

Perform search based on column formatting

By default, the search operation considers the underlying raw data of each cell for searching. However, in some cases, you may want to search based on the formatted data visible to the users. To search data based on column formatting, you can utilize the grid.valueFormatterService.fromView method within the ActionBegin event. This method allows you to retrieve the formatted value of a cell and perform searching on each column using the OR predicate.

The following example demonstrates how to implement searching based on column formatting in the Grid. In the actionBegin event, retrieve the search value from the getColumns method. Iterate through the columns and check whether the column has a format specified. If the column has a format specified, use the grid.valueFormatterService.fromView method to get the formatted value of the cell. If the formatted value matches the search value, set the OR predicate that includes the current column filter and the new filter based on the formatted value.

CSHTML
column-formatting.cs
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("OrderID").HeaderText("OrderID").IsPrimaryKey(true).Width("120").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("120").Add();
    col.Field("Freight").HeaderText("Freight").Width("120").Format("C2").Add();
    col.Field("OrderDate").HeaderText("Order Date").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Width("120").Add();
}).Toolbar(new List<string>() { "Search" }).ActionBegin("actionBegin").KeyPressed("keyPressed").Render()
<script>
    function actionBegin(args) {
        if (args.requestType == 'searching') {
            var grid = document.getElementById("Search").ej2_instances[0];
            args.cancel = true;
            setTimeout(() => {
                var columns = grid.getColumns();
                var predicate = null;
                for (var i = 0; i < columns.length; i++) {
                    var val = grid.valueFormatterService.fromView(
                        args.searchString,
                        columns[i].getParser(),
                        columns[i].type
                    );
                    if (val) {
                        if (predicate == null) {
                            predicate = new ej.data.Predicate(
                                columns[i].field,
                                'contains',
                                val,
                                true,
                                true
                            );
                        } else {
                            predicate = predicate.or(
                                columns[i].field,
                                'contains',
                                val,
                                true,
                                true
                            );
                        }
                    }
                }
                grid.query = new ej.data.Query().where(predicate);
            }, 200);
        }
    }
    function keyPressed(args) {
       if (
            args.key == 'Enter' &&
            args.target &&
            args.target.closest('.e-search') &&
            args.target.value == ''
            ) {
            args.cancel = true;
            document.getElementById("Search").ej2_instances[0].query = new ej.data.Query();
        }
    }
</script>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

Perform search operation in Grid using multiple keywords

In addition to searching with a single keyword, the Grid component offers the capability to perform a search operation using multiple keywords. This feature enables you to narrow down your search results by simultaneously matching multiple keywords. It can be particularly useful when you need to find records that meet multiple search conditions simultaneously. This can be achieved by the ActionBegin event of the Grid.

The following example demonstrates, how to perform a search with multiple keywords in the grid by using the query property when the requestType is searching in the ActionBegin event. The searchString is divided into multiple keywords using a comma (,) as the delimiter. Each keyword is then utilized to create a predicate that checks for a match in the desired columns. If multiple keywords are present, the predicates are combined using an OR condition. Finally, the Grid’s query property is updated with the constructed predicate, and the Grid is refreshed to update the changes in the UI.

On the other hand, the ActionComplete event is used to manage the completion of the search operation. It ensures that the search input value is updated if necessary and clears the query when the search input is empty.

CSHTML
search-multiple-keywords.cs
@Html.EJS().Grid("Search").DataSource((IEnumerable < object >)ViewBag.datasource).Height("350px").Columns(col => {
    col.Field("OrderID").HeaderText("Order ID").IsPrimaryKey(true).Width("120").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("120").Add();
    col.Field("Freight").HeaderText("Freight").Width("120").Format("C2").Add();
    col.Field("ShipCity").HeaderText("Ship City").Width("120").Add();
}).Toolbar(new List < string > () { "Search" }).ActionBegin("actionBegin").ActionComplete("actionComplete").Render()
<script>
    var values;
    var key = '';
    var refresh = false;
    var removeQuery = false;
    var valueAssign = false;
    function actionBegin(args) {
        if (args.requestType == 'searching') {
            var grid = document.getElementById("Search").ej2_instances[0];
            const keys = args.searchString.split(',');
            var flag = true;
            var predicate;
            if (keys.length > 1 && grid.searchSettings.key !== '') {
                this.values = args.searchString;
                keys.forEach((key) => {
                    grid.getColumns().forEach((colum) => {
                        if (flag) {
                            predicate = new ej.data.Predicate(colum.field, 'contains', key, true);
                            flag = false;
                        }
                        else {
                            var newPredicate = new ej.data.Predicate(colum.field, 'contains', key, true);
                            predicate = predicate.or(newPredicate);
                        }
                    });
                });
                grid.query = new ej.data.Query().where(predicate);
                grid.searchSettings.key = '';
                this.valueAssign = true;
                this.removeQuery = true;
                grid.refresh();
            }
        }
    }
    function actionComplete(args) {
        if (args.requestType === 'refresh') {
            var grid = document.getElementById("Search").ej2_instances[0];
            var searchBar = document.querySelector('#' + grid.element.id + '_searchbar');
            if (searchBar) {
                if (this.valueAssign) {
                    searchBar.value = this.values || '';
                    this.valueAssign = false;
                } else if (removeQuery) {
                    searchBar.value = ''
                    grid.query = new ej.data.Query();
                    removeQuery = false;
                    grid.refresh();
                }
            }
        }
    }
</script>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.Datasource = orders;            
   return View();
 }

By using this approach, you can perform a search operation in the grid using multiple keywords.

How to ignore accent while searching

By default, the searching operation in the Grid component does not ignore diacritic characters or accents. However, there are cases where ignoring diacritic characters becomes necessary. This feature enhances the search experience by enabling data searching without considering accents, ensuring a more comprehensive and accurate search and it can be achieved by utilizing the SearchSettings.IgnoreAccent property of the Grid component as true.

The following example demonstrates how to define the IgnoreAccent property within the SearchSettings property of the grid. Additionally, the EJ2 Toggle Switch Button component is included to modify the value of the SearchSettings.IgnoreAccent property. When the switch is toggled, the Change event is triggered, and the SearchSettings.IgnoreAccent property is updated accordingly. This functionality helps to visualize the impact of the SearchSettings.IgnoreAccent setting when performing search operations.

CSHTML
ignore-accent.cs
<div style="display:flex">
    <label style="padding: 1px 10px 20px 0px">
        Enable or disable ignoreAccent property
    </label>
    @Html.EJS().Switch("switch").Change("onSwitchChange").Render()
</div>
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("CategoryName").HeaderText("Category Name").Width("160").Add();
    col.Field("ProductName").HeaderText("Product Name").Width("170").Add();
    col.Field("QuantityPerUnit").HeaderText("Quantity Per Unit").Width("170").Add();
    col.Field("UnitsInStock").HeaderText("Units In Stock").Width("170").Add();
}).Toolbar(new List<string>() { "Search" }).Render();
<script>
    function onSwitchChange(args) { 
        var gridObj = document.getElementById("Search").ej2_instances[0];
        if (args.checked) {
            gridObj.searchSettings.ignoreAccent = true;
        } else {
            gridObj.searchSettings.ignoreAccent = false;
        }
    }
</script>
public IActionResult Index()
 {
   var orders = ProductDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

You can set SearchSettings.IgnoreAccent property along with other search settings such as Fields, Operator, and IgnoreCase to achieve the desired search behavior.

This feature works only for the characters that are not in the ASCII range.

This feature may have a slight impact on search performance.

Highlight the search text

The Syncfusion^® Grid component allows you to visually highlight search results within the displayed data. This feature helps you to quickly identify where the search items are found within the displayed data. By adding a style to the matched text, you can quickly identify where the search items are present in the grid.

To achieve search text highlighting in the Grid, you can utilize the QueryCellInfo event. This event is triggered for each cell during the Grid rendering process, allowing you to customize the cell content based on your requirements.

The following example demonstrates how to highlight search text in grid using the QueryCellInfo event. The QueryCellInfo event checks if the current cell is in the desired search column, retrieves the cell value, search keyword and uses the includes method to check if the cell value contains the search keyword. If it does, the matched text is replaced with the same text wrapped in a span tag with a customcss class. You can then use CSS to define the customcss class and style to easily identify where the search keywords are present in the grid.

CSHTML
highlight-text.cs
@Html.EJS().Grid("Search").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
	col.Field("OrderID").HeaderText("Order ID").Width("160").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Add();
	col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
	col.Field("ShipName").HeaderText("Ship Name").Width("170").Add();
	col.Field("ShipCountry").HeaderText("Ship Country").Width("170").Add();
}).Toolbar(new List<string>() { "Search" }).ActionBegin("onActionBegin").QueryCellInfo("onQueryCellInfo").Render();
<script>
    let key = '';
    function onActionBegin(args) {
        if (args.requestType === 'searching') {
           this.key=args.searchString.toLowerCase();
        }
    }
    function onQueryCellInfo(args) {
        if (this.key !== '') {
            var cellContent = args.data[(args.column).field];
            var parsedContent = cellContent.toString().toLowerCase();
            if (parsedContent.includes(this.key)) {
                var i = 0;
                var searchStr = '';
                while (i < this.key.length) {
                    var index = parsedContent.indexOf(this.key[i]);
                    searchStr = searchStr + cellContent.toString()[index];
                    i++;
                }
                args.cell.innerHTML = args.cell.innerText.replaceAll(
                    searchStr,
                    "<span class='customcss'>" + searchStr + '</span>'
                );
            }
        }
    }
</script>
<style>
	.customcss {
		background-color: yellow;
	}
</style>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

Clear search by external button

The Syncfusion^® Grid component provides a capability to clear searched data in the grid. This functionality offers the ability to reset or clear any active search filters that have been applied to the grid’s data.

To clear the searched grid records from an external button, you can set the SearchSettings.Key property to an empty string to clear the search text. This property represents the current search text in the search box.

The following example demonstrates how to clear the searched records using an external button.

CSHTML
clear-search.cs
<div style="margin-bottom: 20px">
 @Html.EJS().Button("clear").Content("Clear Search").Render()
</div>
@Html.EJS().Grid("Grid").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("Freight").HeaderText("Freight").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
    col.Field("OrderDate").HeaderText("Order Date").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
}).SearchSettings(search => { search.Fields(new string[] { "CustomerID" }).Key("Ha").Operator("contains").IgnoreCase(true); }).Toolbar(new List<string>() { "Search" }).Render()
<script>
    document.getElementById('clear').addEventListener('click', () => {
        var gridObj = document.getElementById("Grid").ej2_instances[0];
        gridObj.searchSettings.key = '';
    });
</script>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }

You can also clear the searched records by using the clear icon within the search input field.

Retrieving searched records using a button click

The Syncfusion Grid allows users to retrieve searched records using an external button. This functionality enables capturing the search text entered in the toolbar and filtering the data accordingly.

To achieve this, the ActionComplete event can be used. This event is triggered when a search action is performed, allowing access to the search text. The captured search string can then be used with the executeQuery method of the DataManager to retrieve the matching records.

The following example demonstrates how to retrieve searched records using an external button.

CSHTML
retrieve-records.cs
<div>
    @Html.EJS().Button("getSearchedRecords").Content("Get Searched Records").Render()
</div>
@Html.EJS().Grid("grid").DataSource((IEnumerable<object>)ViewBag.datasource).Height("350px").Columns(col =>
{
    col.Field("OrderID").HeaderText("Order ID").Width("160").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).IsPrimaryKey(true).Add();
    col.Field("CustomerID").HeaderText("Customer ID").Width("170").Add();
    col.Field("Freight").HeaderText("Freight").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("C2").Add();
    col.Field("OrderDate").HeaderText("Order Date").Width("170").TextAlign(Syncfusion.EJ2.Grids.TextAlign.Right).Format("yMd").Add();
})..AllowPaging().PageSettings(page => { page.PageCount(5);}).Toolbar(new List<string>() { "Search" }).ActionComplete("actionComplete").Render()
<script>
    var lastSearchString = '';
    function actionComplete(args){
        if (args.requestType === 'searching') {
            lastSearchString = args.searchString; // Store the last searched value.
        }
    }
    document.getElementById('getSearchedRecords').addEventListener('click', () => {
        if (lastSearchString) {
            const gridInstance = document.getElementById('grid').ej2_instances[0];
            const data = gridInstance.dataSource;
            new ej.data.DataManager(data).executeQuery(new ej.data.Query().search(lastSearchString, [], undefined, true)).then((e) => {
                console.log('Searched Records:', e.result); // Log searched records.
            });
        }  
    });
</script>
public IActionResult Index()
 {
   var orders = OrdersDetails.GetAllRecords();
   ViewBag.datasource = orders;            
   return View();
 }