Advanced GridView Serach Opeartion in Asp.Net


Information

Introduction

I was searching for a way to include a search textbox option in the ASP.NET GridView control. I couldn’t find an elegant solution and decided to implement it myself. So here’s my solution for the problem.

Why use this solution?

You can use this solution and implement row filtering in a grid very easily. Search and filter operations can be performed by just handling the search event that is raised. In addition, this GridView also allows you to set options to show row serial numbers, total number of rows, and show the header and footer even when no rows are available in the GridView. (By default, the header and footer are hidden when the GridView has no rows to display.)

The solution

What I have done

  1. I’ve extended the GridView and created a SearchableGridView class.
  2. Added a TemplateColumn to display the row number.
  3. Added controls in the footer to handle the search operation.
  4. Raise an event with the search string as argument when a search is fired.

The code

I’ve extended the GridView control as a SearchableGridView to include the search option in the footer of the GridView.
public class SearchGridView : GridView
In order to show the row serial number, I’ve created the following template column:
public class NumberColumn : ITemplate
{
    public void InstantiateIn(Control container)
    {

    }
}
In SearchableGridView, I’ve overridden the OnInit function to add the template column as the first column to show the row serial number, if the ShowRowNumber flag is turned on.
protected override void OnInit(EventArgs e)
{
    base.OnInit(e);
    //If showrownumber option is turned on then add 
    //the template column as the first column.
    if (!IsDesign() && ShowRowNumber) 
    {
        TemplateField tmpCol = new TemplateField();
        NumberColumn numCol = new NumberColumn();
        tmpCol.ItemTemplate = numCol;
        // Insert this as the first column
        this.Columns.Insert(0, tmpCol);
    }
}
The OnRowCreated method is called every time a row is created. During runtime, depending on the RowType, I add the search controls and the number of the row's label (in the footer), the row number (in every row), and the column header for the row number column (in the header).
protected override void OnRowCreated(GridViewRowEventArgs e)
{
    base.OnRowCreated(e);
    if (!IsDesign()) //During Runtime
    {
        if (e.Row.RowType == DataControlRowType.Footer)
        {
            //If ShowFooter is set to true
            if (ShowFooter && e.Row.Cells.Count > 0)
            {
                //If TotalRows has to be shown
                if (ShowTotalRows)
                {
                    e.Row.Cells[0].Text = ViewState[NO_OF_ROWS] + " Rows.";
                }
                if (e.Row.Cells[e.Row.Cells.Count - 1].Controls.Count == 0)
                {
                    //Create the search control
                    Table table = new Table();
                    table.Style.Add("width", "100%");
                    table.Style.Add("align", "right");
                    TableRow tr = new TableRow();
                    TableCell tc = new TableCell();
                    tc.Style.Add("align", "right");
                    tc.Style.Add("width", "100%");

                    //Populate the dropdownlist with the Ids
                    //of the columns to be filtered
                    if (_ddlFinder.Items.Count == 0)
                        SetFilter();

                    _btnSearch.Width = 20;
                    _btnSearch.Height = 20;
                    _btnSearch.ImageAlign = ImageAlign.AbsMiddle;
                    _btnSearch.AlternateText = "Search";
                    //Assign the function that is called when search button is clicked
                    _btnSearch.Click += new ImageClickEventHandler(_btnSearch_Click);
                    
                    tc.Controls.Add(_ddlFinder);
                    tc.Controls.Add(_tbSearch);
                    tc.Controls.Add(_btnSearch);
                    tr.Cells.Add(tc);
                    table.Rows.Add(tr);

                    _pnlSearchFooter.Controls.Add(table);
                    e.Row.Cells[e.Row.Cells.Count - 1].Controls.Add(_pnlSearchFooter);
                
                }
            }
        }
        if (e.Row.RowType == DataControlRowType.Header)
        {
            // If ShowHeader is set to true and 
            // If Row number has to be shown

            if (ShowRowNumber && ShowHeader) 
            {
                e.Row.Cells[0].Text = "Sno";
            }
        }
        else if (e.Row.RowType == DataControlRowType.DataRow)
        {
            if (ShowRowNumber)
            {
                //Set the row number in every row
                e.Row.Cells[0].Text = (e.Row.RowIndex + 
                  (this.PageSize * this.PageIndex) + 1).ToString();
            }
        }
    }
}
The SearchFilters property of the SearchableGridView sets the dropdownlist values for the search option. The Text property of the list item corresponds to the display name in the dropdownlist and the Value property of the list item is the column name of the data source.
public void SetFilter()
{
    _ddlFinder.Items.Clear();
    //Copy the items to the dropdownlist
    foreach (ListItem li in SearchFilters)
        _ddlFinder.Items.Add(li);
}
Now, let's move on to the handling of the search event. For this, I created a delegate and fire the event SearchGrid, when the search button is hit. The search string is formed using the syntax _ddlFinder.SelectedValue + " like '" + _tbSearch.Text.Trim() + "%'".
public delegate void SearchGridEventHandler(string _strSearch);
public event SearchGridEventHandler SearchGrid;

void _btnSearch_Click(object sender, ImageClickEventArgs e)
{
    string sSearchText = ConstructSearchString();
    OnSearchGrid(sSearchText);
}

protected string ConstructSearchString()
{
    string _strText = _tbSearch.Text.Trim();

    if (_strText == string.Empty)
        return string.Empty;

    return _ddlFinder.SelectedValue + " like '" + _strText + "%'";
}

protected void OnSearchGrid(string _strSearch)
{
    if (SearchGrid != null)
    {
        SearchGrid(_strSearch);
    }
}

Showing the footer when no rows are returned

The default property of the GridView is to hide the header and footer when no rows are bound to it. Setting an empty item template would only show the template but not the header or the footer. In our case, the footer has to be shown always, irrespective of the number of rows bound to the SearchableGridView, because the search option should be visible. To achieve this, I had to override the CreateChildControls method as below:
protected override int CreateChildControls(System.Collections.IEnumerable dataSource, 
                                           bool dataBinding)
{
    int count = base.CreateChildControls(dataSource, dataBinding);

    //  no rows in grid. create header and footer in this case
    if (count == 0 && (ShowEmptyFooter || ShowEmptyHeader))
    {
        //  create the table
        Table table = this.CreateChildTable();

        DataControlField[] fields;
        if (this.AutoGenerateColumns)
        {
            PagedDataSource source = new PagedDataSource();
            source.DataSource = dataSource;

            System.Collections.ICollection autoGeneratedColumns = 
                                           this.CreateColumns(source, true);
            fields = new DataControlField[autoGeneratedColumns.Count];
            autoGeneratedColumns.CopyTo(fields, 0);
        }
        else
        {
            fields = new DataControlField[this.Columns.Count];
            this.Columns.CopyTo(fields, 0);
        }

        if (ShowEmptyHeader)
        {
            //  create a new header row
            GridViewRow headerRow = base.CreateRow(-1, -1, DataControlRowType.Header, 
                                                   DataControlRowState.Normal);
            this.InitializeRow(headerRow, fields);
            // Fire the OnRowCreated event to handle showing row numbers
            OnRowCreated(new GridViewRowEventArgs(headerRow));
            //  add the header row to the table
            table.Rows.Add(headerRow);
        }

        //  create the empty row
        GridViewRow emptyRow = new GridViewRow(-1, -1, DataControlRowType.EmptyDataRow, 
                                               DataControlRowState.Normal);
        TableCell cell = new TableCell();
        cell.ColumnSpan = fields.Length;
        cell.Width = Unit.Percentage(100);

        //  respect the precedence order if both EmptyDataTemplate
        //  and EmptyDataText are both supplied ...
        if (this.EmptyDataTemplate != null)
        {
            this.EmptyDataTemplate.InstantiateIn(cell);
        }
        else if (!string.IsNullOrEmpty(this.EmptyDataText))
        {
            cell.Controls.Add(new LiteralControl(EmptyDataText));
        }

        emptyRow.Cells.Add(cell);
        table.Rows.Add(emptyRow);

        if (ShowEmptyFooter)
        {
            //  create footer row
            GridViewRow footerRow = base.CreateRow(-1, -1, DataControlRowType.Footer, 
                                                   DataControlRowState.Normal);
            this.InitializeRow(footerRow, fields);
            // Fire the OnRowCreated event to handle showing
            // search tool and total number of rows
            OnRowCreated(new GridViewRowEventArgs(footerRow));

            //  add the footer to the table
            table.Rows.Add(footerRow);
        }

        this.Controls.Clear();
        this.Controls.Add(table);
    }

    return count;
}

Working sample

Let me illustrate the above control with the help of an example. For this purpose, I have used the Customers table from the NorthWind database.
Step 1: Create a data source dsCustomers with the Select query: "SELECT CustomerID, CompanyName, Address, City, Country FROM Customers".
Step 2 : Create an instance of SearchableGridView and customize the SearchFilters property to have the list of columns on which the search can be performed.

Step 3: Add two hidden fields hfSearchText and hfSort to store the search text and the sort text, respectively.
Step 4: Implement the SearchGrid event to set the search string on the data source and filter the rows in the SearchableGridView. hfSearchText and hfSort are hidden fields that hold the search string and the sort string of the SearchableGridView. The BindData method binds the data after filtering and sorting.
protected void SearchGridView1_SearchGrid(string _strSearch)
{
    hfSearchText.Value = _strSearch;
    BindData();
}

protected void SearchGridView1_Sorting(object sender, GridViewSortEventArgs e)
{
    //If hfSort has the same value as before, 
    //the sorting should be done in descending order
    if (hfSort.Value == e.SortExpression)
        hfSort.Value = e.SortExpression + " Desc";
    else
        hfSort.Value = e.SortExpression;
    BindData();
}

void BindData()
{
    //hfSearchText has the search string returned from the grid.
    if (hfSearchText.Value != "")
        dsCustomers.SelectCommand += " where " + hfSearchText.Value;
    DataView dv = (DataView)dsCustomers.Select(new DataSourceSelectArguments());
    //hfSort has the sort string returned from the grid.
    if (hfSort.Value != "")
        dv.Sort = hfSort.Value;

    SearchGridView1.DataSource = dv;
    try
    {
        SearchGridView1.DataBind();
    }
    catch (Exception exp)
    {
        //If databinding threw exception b’coz current 
        //page index is > than available page index
        SearchGridView1.PageIndex = 0;
        SearchGridView1.DataBind();
    }
    finally
    {
        //Select the first row returned
        if (SearchGridView1.Rows.Count > 0)
            SearchGridView1.SelectedIndex = 0;
    }
}

Conclusion

SearchableGridView will be very useful when there are a large number of rows in the grid. Searching through the rows can be implemented without much hassle.


Download Source Code
0 comments

Conform Message In Code Behing in Asp.Net


Information
Multiple Ways to Call Javascript Function from CodeBehind in ASP.Net

Introduction
JavaScript is one of the very versatile scripting languages that are used in Web applications. Even though we can accomplish everything in server side programming using C#, it is still advisable to do some of the things like validations, etc in clientside using JavaScript. In ASP.Net 1.x, we don’t have that much support in the framework to hook JavaScript functions from the asp.net page dynamically. This drawback was addressed with the release of ASP.Net 2.0 by providing developers a lot many features to embed JavaScript blocks dynamically through a class called ClientScriptManager.

ClientScriptManager Class
We normally add JavaScript functions to our webpage using <Script> tag. There are situations where we need to add the scripts dynamically from the codebehind class. In .NetFramework 1.x version, there is no class that helps us to handle this situation effectively. This drawback was addressed .NetFramework 2.0 by introducing a new class called ClientScriptManager.  This class can be used to manage and add script blocks to the asp.net page from codebehind class.

Things we should know about ClientScriptManager Class
Ø       ClientScript property of the Page object will give us an instance of ClientScriptManager object. We can add the scripts dynamically through this instance which will be then injected in the HTML output.
Ø       This class uniquely identifies scripts by a key String and a Type. Scripts with the same key and type are considered duplicates and hence similar scripts are avoided. This will avoid the confusion caused when we are adding scripts from usercontrols. For example, the method IsClientScriptBlockRegistered() can be used for checking duplicate script registered for RegisterClientScriptBlock() method.

ClientScriptManager class has a set of useful methods which we can use to inject the JavaScript functions in the HTML output. We can choose to use these methods to accomplish our requirements depending on the situation.

Moving forward, we will discuss the usages of below 3 different methods to inject javascript from codebehind file,
1.      RegisterClientScriptBlock() Methods.
2.      RegisterStartupScript() Methods.
3.      RegisterOnSubmitStatement() Methods.

RegisterClientScriptBlock Methods
Page.RegisterStartUpScript() and the Page.RegisterClientScriptBlock() methods in .Netframework 1.x are now considered obsolete. These 2 methods are now packed with ClientScriptManaget class. The RegisterClientScriptBlock() method allows you to place a JavaScript function at the top of the page and gets executed on startup of the page i.e. when loading the page in the browser. There is a additional method called IsClientScriptBlockRegistered() in ClientScriptManager which will return true if a script block is already registered with  the same key, hence we can prevent the duplicate script registration.

There are 2 overloads for this method,
ClientScriptManager.RegisterClientScriptBlock (Type typeofscript, String key, String script)
ClientScriptManager.RegisterClientScriptBlock (Type typeofscript, String key, String script, Boolean addScriptTags)

Usage
Placing this code on page load or a button click makes the script to fire on the start up of subsequent postback.

1st overload
ClientScriptManager script = Page.ClientScript;
        if (!script.IsClientScriptBlockRegistered(this.GetType(), "Alert"))
        {
            script.RegisterClientScriptBlock(this.GetType(), "Alert", "<script type=text/javascript>alert('hi')</script>");
        }

2nd overload
ClientScriptManager script = Page.ClientScript;
if (!script.IsClientScriptBlockRegistered(this.GetType(), "Alert"))
        {
            script.RegisterClientScriptBlock(this.GetType(), "Alert", "alert('hi')",true);
        }



As I said earlier, these methods will make the script block to execute on the startup, thus we can see the alert box before the controls are actually rendered.

RegisterStartupScript Methods
In this section, we will see the usage ClientScriptManager.RegisterStartupScript() method of ClientScriptManager class. Both, RegisterStartupScript() methods and RegisterClientScriptBlock() methods will inject Jscript code that will fire during start up of subsequent postback. But the real difference is the former methods will inject the script after the form open tag but before page controls and the RegisterStartupScript() methods will inject the scripts after page controls but before form close tag. This indicates that injecting script using RegisterClientScriptBlock() method it is not possible to access page controls in the script block while using RegisterStartupScript() method we can.
The below markups will show a part an html output given by the asp.net page when executing these RegisterClientScriptBlock and RegisterStartupScript methods.

RegisterClientScriptBlock Output
    <form name="form1" method="post" action="Default.aspx" id="form1">
<div>
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJMjgzMDgzOTgzZGQfI8LfDKmcT0TXZj8jwrxqI6TOIA==" />
</div>
<script type=text/javascript>alert('hi')</script>

In the above html snippet, we can see the script embedded before the page controls but after form open tag.

RegisterStartupScript Output
<script type="text/javascript">
<!--
alert(document.getElementById('txtName').value)// -->
</script>
</form>
</body>
 In the above html snippet, we can see the script embedded after the page controls but before form close tag thus making the script able to access the page controls as I said earlier.

Overloads
There are 2 overloads for this method,
ClientScriptManager.RegisterClientScriptBlock (Type typeofscript, String key, String script)
ClientScriptManager.RegisterClientScriptBlock (Type typeofscript, String key, String script, Boolean addScriptTags)

Usage
Placing this code on page load or a button click makes the script to fire on the start up of subsequent postback. This method is also has a method called IsStartupScriptRegistered() like RegisterClientScriptBlock() methods which will check for script duplications.

1st overload:
ClientScriptManager script = Page.ClientScript;
txtName.Text = "Satheesh Babu";
        if (!script.IsStartupScriptRegistered (this.GetType(), "Alert"))
        {
            script.RegisterStartupScript (this.GetType(), "Alert", "&lt;script type=text/javascript&gt;alert(document.getElementById('txtName').value)&lt;/script&gt;");
        }

2nd overload:
ClientScriptManager script = Page.ClientScript;
txtName.Text = "Satheesh Babu";
if (!script.IsStartupScriptRegistered (this.GetType(), "Alert"))
        {
            script.RegisterStartupScript (this.GetType(), "Alert", "alert(document.getElementById('txtName').value)",true);
        }

When the above code is executed we will get an output like,

Here, the script block will get executed after the controls in the page are rendered and the controls in the page will be visible to the script as opposed to RegisterClientScriptBlock() method, refer the above figure. Thus we can access the page controls from the script block when using RegisterStartupScript() method.
RegisterOnSubmitStatement() Method
This section will discuss the implementation of ClientScriptManager.RegisterOnSubmitStatement() of ClientScriptManager class. Sometimes, we will require getting confirmation from the user before submitting the form to server. For example, in an input form we would like to get the confirmation from the users before storing it to the database whose validity cannot be determined through validation functions. This method can be used in such situations to provide a confirmation dialogs. This method registers scripts which will be executed at the time of submit click of a page.

Syntax
public void RegisterOnSubmitStatement (
    Type type,
    string key,
    string script
)

Usage
Placing this code on page load makes the script to fire on every submit click of the webform.

if (!script.IsClientScriptBlockRegistered(this.GetType(), "SubmitScript"))
        {
            script.RegisterOnSubmitStatement(this.GetType(), "SubmitScript", "alert('Submit Clicked')");
        }

Consider the below code,
protected void Page_Load(object sender, EventArgs e)
    {    
ClientScriptManager script = Page.ClientScript;
if (!script.IsClientScriptBlockRegistered(this.GetType(), "SubmitScript"))
     {
          script.RegisterOnSubmitStatement(this.GetType(), "SubmitScript", "return confirm('Are you sure to continue')");
     }
    }
    protected void btnSubmit_Click(object sender, EventArgs e)
    {
        Response.Write("Form is Submitted.");
    }

Executing the above code will bring a webform, Clicking Submit will bring a confirm box like the below figure,


Clicking Cancel will not execute the submit click event, where clicking OK will execute the event and output will be like,
0 comments
Subscribe to: Posts (Atom)