GridView C# - W3spoint

In C#, a GridView is a control that allows you to display tabular data in a grid format on a web page. It is commonly used in web applications to present data in a structured and organized manner. The GridView control is part of the ASP.NET framework and is available in the System.Web.UI.WebControls namespace.

Here’s an example of how you can use the GridView control in C#:

Create a new ASP.NET web application project in Visual Studio.
Open the desired web form (.aspx) where you want to add the GridView control.
In the design view of the web form, drag and drop a GridView control from the Toolbox onto the form.
Once the GridView control is added to the form, you can customize its appearance and behavior using the Properties window. You can set properties like AutoGenerateColumns, DataSource, and so on.
In the code-behind file (the .aspx.cs file), you need to write code to populate the GridView with data. You can do this by assigning a data source to the GridView control and calling the DataBind() method.

Here’s a simple example that demonstrates populating a GridView with data from a database:

using System;
using System.Data;
using System.Data.SqlClient;
using System.Web.UI;

public partial class Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            // Retrieve data from the database
            DataTable dt = GetDataFromDatabase();

            // Assign the data source to the GridView
            GridView1.DataSource = dt;

            // Bind the data to the GridView
            GridView1.DataBind();
        }
    }

    private DataTable GetDataFromDatabase()
    {
        // Connection string for the database
        string connectionString = "your_connection_string";

        // SQL query to retrieve data
        string query = "SELECT * FROM YourTable";

        // Create a new DataTable
        DataTable dt = new DataTable();

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Open the database connection
                connection.Open();

                // Execute the query and load data into the DataTable
                SqlDataAdapter adapter = new SqlDataAdapter(command);
                adapter.Fill(dt);
            }
        }

        return dt;
    }
}

In this example, the Page_Load event handler is used to populate the GridView with data when the page is loaded. The GetDataFromDatabase method retrieves the data from the database using a SQL query and returns a DataTable. The DataTable is then assigned as the data source for the GridView, and the DataBind method is called to bind the data to the GridView.

Note: Replace "your_connection_string" with the actual connection string for your database, and "YourTable" with the actual table name from your database.

This is a basic example to get you started with the GridView control in C#. You can further customize the appearance and behavior of the GridView by modifying its properties or handling various events.

Features of GridView in C#:

The GridView control in C# provides several features that allow you to display and manipulate tabular data on a web page. Here are some of the key features of the GridView control:

Data Binding: The GridView control supports data binding, allowing you to bind it to various data sources such as databases, collections, or XML files. You can assign a data source to the GridView and use the DataBind() method to populate it with data.
Automatic Columns: By default, the GridView control automatically generates columns based on the data source schema. It creates columns for each field or property in the data source. You can also manually define columns and customize their appearance and behavior.
Sorting: The GridView control provides built-in sorting capabilities. Users can click on column headers to sort the data in ascending or descending order. You can enable sorting for specific columns or for the entire GridView.
Paging: When dealing with large datasets, the GridView control allows you to implement paging. You can specify the number of records to display per page and provide navigation controls to move between pages of data.
Editing and Updating: The GridView control supports editing and updating of data. You can configure it to allow users to edit individual rows, and provide update and cancel buttons for committing or canceling changes. Events like RowEditing, RowUpdating, and RowCancelingEdit are available for handling these operations.
Deleting: The GridView control allows users to delete rows of data. You can enable row deletion and handle the RowDeleting event to perform the necessary deletion operations.
Selection: Users can select individual rows or multiple rows in the GridView. You can enable row selection and handle events like SelectedIndexChanging or SelectedIndexChanged to perform actions based on the selected rows.
Templating: The GridView control supports templating, which allows you to customize the appearance and layout of the data using templates. You can define templates for header, footer, and individual columns using various controls and HTML markup.
Styling and Formatting: You can apply CSS styles to the GridView control to customize its appearance. You can define styles for header, row, and alternate row, and also apply conditional formatting based on data values.
Event Handling: The GridView control provides a set of events that you can handle to respond to user actions or perform additional operations. Events like RowDataBound, RowCommand, and RowCreated allow you to interact with the GridView at different stages of its lifecycle.

These are some of the key features provided by the GridView control in C#. It offers a range of functionalities to display, manipulate, and interact with tabular data in a web application.

Properties of GridView in C#:

The GridView control in C# provides various properties that allow you to customize its behavior, appearance, and data binding. Here are some important properties of the GridView control:

AutoGenerateColumns: Specifies whether the columns should be automatically generated based on the data source schema. Set it to true to let the GridView generate columns automatically, or false to manually define columns.
Columns: Represents the collection of column fields in the GridView. You can use this property to add, remove, or customize individual columns. Columns can be of various types, such as BoundField, ButtonField, HyperLinkField, TemplateField, etc.
DataSource: Gets or sets the data source object for the GridView. You can assign various types of data sources, such as DataTable, DataSet, DataView, List<T>, or IQueryable<T>.
DataKeyNames: Specifies the primary key field(s) of the data source. This property is used to identify the unique key value of each row. It is commonly used for operations like editing, updating, or deleting rows.
AllowSorting: Specifies whether sorting is enabled for the GridView. Set it to true to enable sorting, or false to disable sorting. Users can click on column headers to sort the data.
AllowPaging: Specifies whether paging is enabled for the GridView. Set it to true to enable paging, or false to disable paging. When enabled, the GridView displays a set number of rows per page.
PageSize: Specifies the number of rows to display per page when paging is enabled. You can set the desired number of rows to be shown on each page.
EmptyDataText: Specifies the text to display when the GridView control has no data to show. You can set a custom message or prompt to inform users about the absence of data.
EditIndex: Specifies the index of the row in edit mode. Use this property to programmatically set the row that should be editable. Set it to -1 to indicate that no row is in edit mode.
SelectedIndex: Specifies the index of the selected row. Use this property to programmatically select a row in the GridView.
ShowHeader/Footer: Specifies whether the header or footer row should be displayed. Set it to true to display the header/footer, or false to hide them.
CssClass: Specifies the CSS class to apply to the GridView control. You can use this property to apply custom styles and control the appearance of the GridView.
RowStyle/AlternatingRowStyle: Represents the style properties for the regular and alternating rows of the GridView. You can use these properties to customize the appearance of rows, such as background color, font, etc.

These are some of the important properties of the GridView control in C#. By manipulating these properties, you can customize the behavior and appearance of the GridView to suit your requirements.

Using GridView in C#:

To use the GridView control in C#, you need to follow these steps:

Create a new ASP.NET web application project in Visual Studio.
Open the desired web form (.aspx) where you want to use the GridView control.
In the design view of the web form, drag and drop a GridView control from the Toolbox onto the form.
Customize the appearance and behavior of the GridView control by modifying its properties in the Properties window. Set properties like AutoGenerateColumns, AllowSorting, AllowPaging, etc., as per your requirements.
In the code-behind file (the .aspx.cs file), write code to populate the GridView with data.
a. Retrieve data from a data source (e.g., a database) and store it in a suitable object like a DataTable or List<T>.

b. Assign the data source to the GridView’s DataSource property.

c. Call the DataBind() method to bind the data to the GridView.
Optionally, handle any relevant events of the GridView to perform additional operations or respond to user actions. For example, you can handle events like RowDataBound, RowCommand, etc.

Here’s an example that demonstrates the usage of the GridView control:

using System;
using System.Data;
using System.Data.SqlClient;
using System.Web.UI;

public partial class Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            // Retrieve data from the database
            DataTable dt = GetDataFromDatabase();

            // Assign the data source to the GridView
            GridView1.DataSource = dt;

            // Bind the data to the GridView
            GridView1.DataBind();
        }
    }

    private DataTable GetDataFromDatabase()
    {
        // Connection string for the database
        string connectionString = "your_connection_string";

        // SQL query to retrieve data
        string query = "SELECT * FROM YourTable";

        // Create a new DataTable
        DataTable dt = new DataTable();

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Open the database connection
                connection.Open();

                // Execute the query and load data into the DataTable
                SqlDataAdapter adapter = new SqlDataAdapter(command);
                adapter.Fill(dt);
            }
        }

        return dt;
    }
}

Note: Replace "your_connection_string" with the actual connection string for your database, and "YourTable" with the actual table name from your database.

This is a basic example to get you started with using the GridView control in C#. You can further customize the appearance and behavior of the GridView by modifying its properties or handling various events.

Conclusion:

In conclusion, the GridView control in C# is a powerful tool for displaying and manipulating tabular data in web applications. It provides a wide range of features and properties that allow you to customize its behavior, appearance, and data binding.

By using the GridView control, you can easily bind it to various data sources, such as databases or collections, and display the data in a structured grid format. You can enable sorting, paging, and selection of rows, providing a user-friendly interface for data interaction.

The GridView control also supports editing, updating, and deleting rows, allowing users to modify data directly from the grid. Templating and styling options give you the flexibility to customize the look and feel of the GridView to match your application’s design.

With the event-handling capabilities of the GridView control, you can respond to user actions and perform additional operations based on the selected rows or data changes.

Overall, the GridView control is a valuable tool for handling tabular data in web applications, providing a versatile and customizable way to present and manipulate data.