ASP.NET and ADO.NET Fundamentals

Introduction to ASP.NET and ADO.NET Fundamentals

Welcome to this comprehensive course on ASP.NET and ADO.NET. Whether you are new to web development or looking to solidify your knowledge, this guide will walk you through the core concepts that power modern .NET web applications. By the end of the lesson you will understand how to manage database connections, work with common Web Forms controls, and navigate the ASP.NET page lifecycle—all while following best practices for SEO‑friendly content.

Connecting to a Database with ADO.NET

Key Object: SqlConnection

The foundation of any data‑driven application is the ability to establish a reliable connection to a database. In ADO.NET, the SqlConnection object represents this link to a Microsoft SQL Server instance.

• Purpose: Opens, maintains, and closes a physical connection.
• Typical usage pattern:

  using (SqlConnection conn = new SqlConnection(connectionString)) {
      conn.Open();
      // Execute commands
  }
  

• Important properties:
  • ConnectionString – contains server name, database, authentication details.
  • State – indicates whether the connection is open, closed, or connecting.

Choosing the correct connection object is essential for performance and security. SqlCommand, SqlDataReader, and DataSet are all used *after* the connection is established, but they do not create the connection themselves.

Retrieving Data: ExecuteScalar vs. ExecuteReader

When to use ExecuteScalar()

If you need a single value—such as a total amount, a count, or a specific field—ExecuteScalar() is the most efficient method. It sends the command to the server, retrieves the first column of the first row in the result set, and then closes the connection automatically.

using (SqlCommand cmd = new SqlCommand("SELECT COUNT(*) FROM Orders", conn)) {
    int orderCount = (int)cmd.ExecuteScalar();
}

Contrast this with ExecuteReader(), which returns a forward‑only SqlDataReader for processing multiple rows, and ExecuteNonQuery(), which is used for INSERT, UPDATE, or DELETE statements that do not return rows.

ASP.NET Web Forms Controls

GridView: Automatic Column Generation

The GridView control simplifies the display of tabular data. By setting the AutoGenerateColumns property to true, the GridView automatically creates a column for each field in the bound data source.

<asp:GridView ID="gvProducts" runat="server" AutoGenerateColumns="true" />

If you need custom column layouts, you can set AutoGenerateColumns="false" and define BoundField or TemplateField elements manually.

DropDownList: Detecting User Selection

When a user selects a different item in a DropDownList, the SelectedIndexChanged event fires. This event is essential for reacting to user choices, such as filtering data or updating other controls.

<asp:DropDownList ID="ddlCategories" runat="server" AutoPostBack="true" OnSelectedIndexChanged="ddlCategories_SelectedIndexChanged">
    <asp:ListItem Text="All" Value="0" />
    <asp:ListItem Text="Books" Value="1" />
</asp:DropDownList>

Notice the AutoPostBack="true" attribute—without it, the event would not trigger until another postback occurs.

State Management in ASP.NET

Session State

To preserve user‑specific data across multiple requests, ASP.NET provides the Session object. Unlike ViewState, which stores data in a hidden field on the page, Session data resides on the server, making it more secure for sensitive information.

// Storing a value
Session["UserName"] = "Alice";

// Retrieving a value
string user = Session["UserName"] as string;

Session can be configured to use In‑Process, State Server, or SQL Server storage, depending on scalability requirements.

Other State Mechanisms

• ViewState – persists page‑level data between postbacks; encoded in the page markup.
• Cookies – client‑side storage, useful for small pieces of data like preferences.
• Cache – application‑wide storage for data that does not change per user.

ASP.NET Configuration Files

The Role of Web.config

Every ASP.NET application contains a Web.config file at its root. This XML file holds global configuration settings such as connection strings, authentication modes, custom error pages, and app settings.

<configuration>
    <connectionStrings>
        <add name="MyDb" connectionString="Server=.;Database=Shop;Trusted_Connection=True;" providerName="System.Data.SqlClient" />
    </connectionStrings>
    <appSettings>
        <add key="SiteTitle" value="My Online Store" />
    </appSettings>
</configuration>

Modifying Web.config triggers an application restart, so changes should be planned carefully in production environments.

Understanding the ASP.NET Page Lifecycle

First Event During a Postback: Page_Init

When a page posts back to the server, the lifecycle begins with Page_Init. This event is where you typically create or re‑create dynamic controls and set initialization values before view state is loaded.

protected void Page_Init(object sender, EventArgs e) {
    // Dynamically add a button
    Button btn = new Button();
    btn.ID = "btnDynamic";
    btn.Text = "Click Me";
    form1.Controls.Add(btn);
}

Following Page_Init, the sequence continues with LoadViewState, Page_Load, Control Events, Page_PreRender, and finally Render. Understanding this order helps prevent common bugs such as losing dynamic controls after postback.

Basic CSS Syntax for ASP.NET Pages

Correct Rule for Setting Text Color

Styling your ASP.NET pages follows standard CSS conventions. The proper syntax to set the body text color to black is:

body {color: black;}

Notice the selector body, the opening and closing braces, and the colon separating the property from its value. Incorrect formats—such as missing braces or using an equals sign—will be ignored by browsers.

Putting It All Together: A Mini Project

To reinforce the concepts covered, build a simple product catalog page using the following steps:

1. Create a Web.config entry for the database connection.
2. In the code‑behind, open a SqlConnection and use ExecuteScalar() to display the total number of products.
3. Bind a GridView to a SqlDataReader with AutoGenerateColumns="true".
4. Add a DropDownList for category filtering; handle the SelectedIndexChanged event to re‑query the data.
5. Store the selected category in Session so the choice persists across postbacks.
6. Apply a simple CSS rule (body {color: black;}) to ensure consistent styling.

By completing this mini project, you will have practiced database connectivity, data retrieval methods, Web Forms controls, state management, configuration handling, and basic styling—all essential skills for any ASP.NET developer.

Conclusion and Next Steps

Mastering the fundamentals of ASP.NET and ADO.NET provides a solid platform for building robust, data‑driven web applications. Continue your learning journey by exploring:

• Entity Framework for ORM‑based data access.
• ASP.NET MVC and Razor Pages for modern, testable architectures.
• Advanced state management techniques such as distributed caching.
• Security best practices, including authentication, authorization, and protection against SQL injection.

Stay curious, keep coding, and remember that each concept you master brings you one step closer to becoming an expert in the .NET ecosystem.