1.Describe the purpose of a Command object in ADO.NET.

The Command object in ADO.NET is used to execute SQL queries and stored procedures
against a database. It facilitates communication between an application and the database.

2.Interpret how a DataAdapter acts as a bridge between a DataSet and the database.
In ADO.NET, the DataAdapter serves as an intermediary between a DataSet and a
database, enabling smooth data retrieval and updates without requiring a continuous
connection to the database.
Roles of DataAdapter
1. Fetching Data from the Database
o Uses SQL queries (SELECT) to fill a DataSet.
o Works with DataReader internally for efficient data transfer.
2. Updating the Database
o Syncs changes made in the DataSet back to the database using INSERT,
UPDATE, and DELETE commands.
3. Managing Disconnected Data Access
• Allows applications to modify data locally without requiring a constant database
connection.
• Improves performance and scalability.

How DataAdapter Works:

Operation Method Used Purpose

Fetch Data Fill(DataSet) Populates a DataSet with records from the database
Update Database Update(DataSet) Applies changes in the DataSet back to the database

3.Explain the architecture of ADO.NET and its core components.

OR
12.Explain ADO.NET architecture with a neat diagram.
ADO.NET (ActiveX Data Objects for .NET) is the data access technology used in the .NET
framework to interact with databases. It provides a scalable, efficient, and disconnected
approach to handling data.
1. ADO.NET Architecture Overview
ADO.NET consists of two primary data access models:
✅ Connected Mode: Uses Connection, Command, and DataReader for fast, real-time
database interactions.
✅ Disconnected Mode: Uses DataAdapter and DataSet for offline modifications,
reducing database load.
2. Core Components of ADO.NET
ADO.NET has several key components for managing data communication between an
application and a database.
1. Connection Object (SqlConnection)
• Establishes a connection to the database.
• Supports different database providers (SQL Server, Oracle, MySQL).
2. Command Object (SqlCommand)
• Executes SQL statements, such as SELECT, INSERT, UPDATE, and DELETE.
• Can call stored procedures.
3. DataReader (SqlDataReader)
• Retrieves read-only, forward-only data from the database (fastest method).
• Efficient for quick queries that do not require in-memory manipulation.
4. DataAdapter (SqlDataAdapter)
• Acts as a bridge between the DataSet and the database.
• Uses Fill() to load data into memory.
• Uses Update() to apply changes back to the database.
5. DataSet (DataSet)
• Stores disconnected, in-memory data for offline manipulation.
• Allows multiple tables, relationships, and constraints.
4.Develop an ADO.NET applications in C# to demonstrate the DataReader, DataSet,
.DataAdapter and DataView Objects.
using System;
using System.Data;
using System.Data.SqlClient;

class AdoNetDemo
{
static void Main()
{
string connectionString = "your_connection_string_here";

using (SqlConnection conn = new SqlConnection(connectionString))

{
conn.Open();

// ---------------- Using DataReader ----------------

Console.WriteLine("Reading data using SqlDataReader:");
using (SqlCommand cmd = new SqlCommand("SELECT * FROM Employees", conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Console.WriteLine($"{reader["EmployeeID"]}: {reader["Name"]} -
{reader["Position"]}");
}
}

// ---------------- Using DataAdapter & DataSet ----------------

 SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Employees",
conn);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet, "Employees");

Console.WriteLine("\nDisplaying data using DataSet:");

foreach (DataRow row in dataSet.Tables["Employees"].Rows)
{
Console.WriteLine($"{row["EmployeeID"]}: {row["Name"]} - {row["Position"]}");
}

// ---------------- Using DataView ----------------

DataView dataView = new DataView(dataSet.Tables["Employees"]);
dataView.RowFilter = "Salary > 65000";

Console.WriteLine("\nFiltered data using DataView:");

foreach (DataRowView row in dataView)
{
Console.WriteLine($"{row["EmployeeID"]}: {row["Name"]} - {row["Position"]}");
}
}
}
}

5.write a C# program that establishes a connection to a database using SqlConnection.

using System;
using System.Data.SqlClient;

class DatabaseConnectionDemo
{
static void Main()
{
// Define connection string
string connectionString =
"Server=your_server_name;Database=your_database_name;User
Id=your_username;Password=your_password;";

// Create connection object

using (SqlConnection conn = new SqlConnection(connectionString))
{
try
{
conn.Open(); // Open connection
Console.WriteLine("Database Connection Established Successfully!");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
} // Connection is automatically closed here due to 'using'
}
}

6.Describe data providers and data readers.

1. Data Providers
A data provider is a set of components that facilitate communication between a C#
application and a database. Each data provider is tailored for a specific type of database
(e.g., SQL Server, Oracle, MySQL).
2. Data Readers
A DataReader retrieves read-only, forward-only data fast and efficiently from a database.
Unlike DataSet, which holds data in-memory, DataReader streams records one by one.

7.Discuss connection object in C# .net

Connection Object in C#.NET (ADO.NET)
The Connection object in ADO.NET is responsible for establishing and managing a link
between a C# application and a database. It allows the execution of queries, transactions,
and other operations by opening a session with the data source.
1. Purpose of the Connection Object

✅ Establishes Communication – Connects the application to the database.

✅ Manages Database Sessions – Opens and closes connections as needed.
✅ Handles Authentication – Uses connection strings for security credentials.
✅ Supports Transactions – Enables multiple operations in a single atomic process.
✅ Improves Performance – Uses connection pooling for efficiency.
2. Types of Connection Objects
ADO.NET supports different database providers, each with a corresponding connection
object:

Database Type Connection Object Namespace

SQL Server SqlConnection System.Data.SqlClient

Oracle OracleConnection System.Data.OracleClient

MySQL MySqlConnection MySql.Data.MySqlClient

ODBC (Generic Database) OdbcConnection System.Data.Odbc

OLE DB OleDbConnection System.Data.OleDb

8.Explain with a neat diagram the components of ADO.NET entity framework.

ADO.NET Entity Framework Architecture and Components
The ADO.NET Entity Framework (EF) is an ORM (Object-Relational Mapping) framework
that simplifies database access and management in .NET applications. It allows
developers to interact with data using C# objects instead of SQL queries.
Key Components of Entity Framework
The Entity Framework architecture consists of several layers:
Component Purpose

Database Layer Represents the actual database (SQL Server, MySQL, Oracle)

Entity Data Model (EDM) Defines the schema of entities mapped to tables

DbContext Manages database interactions (CRUD operations)

Entity Classes Defines objects representing database records

LINQ-to-Entities Allows querying data using LINQ instead of SQL

Migration & Change Tracking Helps version control and automatic schema updates

9.Illustrate with relevant example program the procedure of getting connected to a

database and running insert and select queries.
C# Program: Connecting to a Database and Running INSERT & SELECT Queries Using
ADO.NET

This example demonstrates how to: ✅ Establish a database connection using

SqlConnection.
✅ Insert data into a table using INSERT.
✅ Retrieve data using SELECT.
1. Prerequisites
• Ensure SQL Server is installed and running.
 • Create a table named Employees in the database.
CREATE TABLE Employees (
EmployeeID INT PRIMARY KEY IDENTITY(1,1),
Name VARCHAR(50),
Position VARCHAR(50),
Salary DECIMAL(10,2)
);

2. C# Program for Insert & Select Queries

using System;
using System.Data.SqlClient;
class Program
{
static void Main()
{
string connectionString =
"Server=your_server_name;Database=your_database_name;User
Id=your_username;Password=your_password;";
using (SqlConnection conn = new SqlConnection(connectionString))
{
try
{
conn.Open();
Console.WriteLine("Database Connected Successfully!");

// ---------------- Insert Data ----------------

string insertQuery = "INSERT INTO Employees (Name, Position, Salary) VALUES
(@Name, @Position, @Salary)";
using (SqlCommand insertCmd = new SqlCommand(insertQuery, conn))
{
 insertCmd.Parameters.AddWithValue("@Name", "Alice");
insertCmd.Parameters.AddWithValue("@Position", "Manager");
insertCmd.Parameters.AddWithValue("@Salary", 75000);

int rowsInserted = insertCmd.ExecuteNonQuery();

Console.WriteLine($"{rowsInserted} row(s) inserted successfully!");
}

// ---------------- Retrieve Data ----------------

string selectQuery = "SELECT EmployeeID, Name, Position, Salary FROM
Employees";
using (SqlCommand selectCmd = new SqlCommand(selectQuery, conn))
using (SqlDataReader reader = selectCmd.ExecuteReader())
{
Console.WriteLine("\nEmployee Records:");
while (reader.Read())
{
Console.WriteLine($"ID: {reader["EmployeeID"]}, Name: {reader["Name"]},
Position: {reader["Position"]}, Salary: {reader["Salary"]}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
} // Connection automatically closed here due to 'using'
}
}
10.Explain any two types of inheritance.
1. Single Inheritance

✅ Definition: A single child class inherits from a single parent class.

✅ Purpose: Allows extension of functionality while keeping the base implementation
intact
2. Multilevel Inheritance

✅ Definition: A class inherits from another class, which itself inherits from a third class.
✅ Purpose: Establishes a hierarchical relationship, allowing deeper extension of
functionality.

11.Explain a garbage collection in C#.

Garbage Collection (GC) in C# is an automatic memory management feature that helps
free unused objects in the managed heap, preventing memory leaks and improving
performance.

13.Evaluate the steps involved in establishing connections to SQL Server, OLEDB, and
ODBC databases using ADO.NET.
1. Connecting to SQL Server Database Using SqlConnection

✅ Provider: System.Data.SqlClient
✅ Best Used For: Microsoft SQL Server
Steps
1. Import the System.Data.SqlClient namespace.
2. Define the connection string.
3. Create an SqlConnection object.
4. Open the connection.
5. Execute commands (INSERT, SELECT, etc.).
6. Close the connection.
2. Connecting to an OLEDB Database Using OleDbConnection

✅ Provider: System.Data.OleDb
✅ Best Used For: Access, Excel, and other OLE DB-compatible databases
Steps
 1. Import the System.Data.OleDb namespace.
2. Define the connection string.
3. Create an OleDbConnection object.
4. Open the connection.
5. Execute commands (INSERT, SELECT, etc.).
6. Close the connection.
3. Connecting to an ODBC Database Using OdbcConnection

✅ Provider: System.Data.Odbc
✅ Best Used For: Generic databases that support ODBC drivers
Steps
1. Import the System.Data.Odbc namespace.
2. Define the connection string.
3. Create an OdbcConnection object.
4. Open the connection.
5. Execute commands (INSERT, SELECT, etc.).
6. Close the connection.

14.Write a steps for creating a connection to SqlServer Database.

Steps to Create a Connection to a SQL Server Database in C# (ADO.NET)
Establishing a connection to SQL Server using ADO.NET involves several steps. Below is a
structured approach:
1. Install Required Libraries

✅ Ensure .NET Framework or .NET Core SDK is installed.

✅ Use System.Data.SqlClient for database interaction.
2. Define the Connection String

✅ A connection string includes server name, database name, credentials, and

authentication mode.
✅ Example connection string:
string connectionString =
"Server=your_server_name;Database=your_database_name;User
Id=your_username;Password=your_password;";
🔹 Replace your_server_name and your_database_name with actual values.
3. Create and Open a Connection

✅ Use SqlConnection to establish communication with SQL Server.

using System.Data.SqlClient;

using (SqlConnection conn = new SqlConnection(connectionString))

{
conn.Open(); // Opens the database connection
Console.WriteLine("Connected to SQL Server Successfully!");
}

✔ Best Practice: Use using to ensure the connection is closed automatically.

4. Execute SQL Commands

✅ Use SqlCommand to execute queries like SELECT, INSERT, UPDATE, DELETE.

string query = "SELECT * FROM Employees";
using (SqlCommand cmd = new SqlCommand(query, conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Console.WriteLine($"ID: {reader["EmployeeID"]}, Name: {reader["Name"]}");
}

} ✔ DataReader retrieves data in a forward-only, fast manner.

5. Close the Connection

✅ Always close the connection when done.

conn.Close(); // Closes the connection manually (if not using 'using') ✔ Alternative: The
using statement automatically closes the connection.
15.Compare connected and disconnect architecture in ADO.NET.
1. Connected Architecture

✅ Definition: Requires a continuous connection to the database while retrieving and

processing data.
✅ Component: Uses SqlDataReader for efficient, forward-only, read-only data retrieval.

✅ Best For:
✔ Fetching real-time data from large databases.
✔ Fast execution with minimal memory usage.
✔ Ideal for reporting and quick queries.

❌ Limitations:
⛔ Requires a constant connection, which can overload the database.
⛔ Can only read forward, making repeated access difficult
2. Disconnected Architecture

✅ Definition: Retrieves data from the database, stores it in memory (DataSet), and
disconnects from the database, allowing offline data manipulation.
✅ Component: Uses SqlDataAdapter and DataSet for batch processing.

✅ Best For:
✔ Offline data processing without needing a constant connection.
✔ Batch updates (modifying multiple records at once).
✔ Storing multiple tables in memory, allowing complex operations.

❌ Limitations:
⛔ Requires more memory since it holds multiple records in RAM.
⛔ Slower performance compared to DataReader when handling huge datasets.

16.Write an ADO.NET application in C# to demonstrate the DataReader.

using System;
using System.Data.SqlClient;

class Program
{
static void Main()
{
 string connectionString = "Server=your_server_name;Database=CompanyDB;User
Id=your_username;Password=your_password;";

using (SqlConnection conn = new SqlConnection(connectionString))

{
try
{
conn.Open();
Console.WriteLine("Connected to SQL Server Successfully!");

// Using DataReader to fetch employee records

string query = "SELECT EmployeeID, Name, Position, Salary FROM Employees";
using (SqlCommand cmd = new SqlCommand(query, conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
Console.WriteLine("\nEmployee Records:");
while (reader.Read()) // Looping through retrieved rows
{
Console.WriteLine($"ID: {reader["EmployeeID"]}, Name: {reader["Name"]},
Position: {reader["Position"]}, Salary: {reader["Salary"]}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
} // Connection automatically closes due to 'using'
}
}
17.Construct a simple C# application for new user creation with username, password,
confirm password, email and mobile no fields. And insert the data into database by using
command object.
using System;
using System.Data.SqlClient;

class UserRegistration
{
static void Main()
{
string connectionString =
"Server=your_server_name;Database=your_database_name;User
Id=your_username;Password=your_password;";

Console.WriteLine("Enter Username:");
string username = Console.ReadLine();

Console.WriteLine("Enter Password:");
string password = Console.ReadLine();

Console.WriteLine("Confirm Password:");
string confirmPassword = Console.ReadLine();

if (password != confirmPassword)
{
Console.WriteLine("Passwords do not match! Please try again.");
return;
}
 Console.WriteLine("Enter Email:");
string email = Console.ReadLine();

Console.WriteLine("Enter Mobile No:");

string mobileNo = Console.ReadLine();

using (SqlConnection conn = new SqlConnection(connectionString))

{
try
{
conn.Open();
string query = "INSERT INTO Users (Username, Password, Email, MobileNo)
VALUES (@Username, @Password, @Email, @MobileNo)";

using (SqlCommand cmd = new SqlCommand(query, conn))

{
cmd.Parameters.AddWithValue("@Username", username);
cmd.Parameters.AddWithValue("@Password", password);
cmd.Parameters.AddWithValue("@Email", email);
cmd.Parameters.AddWithValue("@MobileNo", mobileNo);

int rowsInserted = cmd.ExecuteNonQuery();

Console.WriteLine(rowsInserted > 0 ? "User Registered Successfully!" :
"Registration Failed!");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
 }
}
}

18.How do you establish a connection to a SQL Server database using ADO.NET in C#?
ADO.NET provides the SqlConnection class to create and manage connections to a SQL
Server database.
Steps to Establish a Connection
1 Import the ADO.NET namespace (System.Data.SqlClient).
2 Define the connection string with server and authentication details.
3 Create an instance of SqlConnection and pass the connection string.
4 Open the connection using conn.Open().
5 Perform database operations (e.g., querying, inserting data).
6 Close the connection using conn.Close() or using statement

19.What is a connection string in ADO.NET?

A connection string in ADO.NET is a string that contains information required to establish
a connection between a C# application and a database (such as SQL Server, MySQL, or
Oracle).

21.What are the differences between connecting to a database using OLEDB and ODBC?
Provide sample connection strings for each.

Feature OLEDB (OleDbConnection) ODBC (OdbcConnection)

Object Linking and Embedding

Full Name Open Database Connectivity
Database

Provider
Supports COM-based data access Uses driver-based architecture
Type

Best Use Generic databases via ODBC

Microsoft Access, Excel, SQL Server
Case drivers

Works with relational and non-

Flexibility Primarily for relational databases
relational sources
Feature OLEDB (OleDbConnection) ODBC (OdbcConnection)

Optimized for client-server

Performance Faster for local Microsoft applications
databases

Data Source Requires OLEDB provider Requires ODBC driver

Still widely used for cross-platform

Support Being phased out for newer tech
access

Example Connection Strings

OLEDB Connection String (Microsoft Access)
string oledbConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\\myDatabase.mdb;";ODBC Connection String (SQL Server)
string odbcConnectionString = "Driver={SQL
Server};Server=myServer;Database=myDB;Uid=myUser;Pwd=myPass;";

22.What are the differences between ExecuteReader(), ExecuteNonQuery(), and

ExecuteScalar() methods in the SqlCommand class?
1. ExecuteReader() – Retrieve Multiple Rows

🔹 Used for reading multiple rows using SqlDataReader.

🔹 Best for queries that return multiple records.

✅ Best For: Fetching tabular data (e.g., displaying records in a grid).

⛔ Limitation: Requires an open connection while reading data.
2. ExecuteNonQuery() – Modify Data

🔹 Used for INSERT, UPDATE, DELETE operations.

🔹 Returns an integer representing the number of affected rows.

✅ Best For: Making changes to the database without retrieving data.

⛔ Limitation: Does not return any records.
3. ExecuteScalar() – Retrieve a Single Value

🔹 Used when only one value needs to be retrieved (e.g., count, sum, max, min).
🔹 Returns an object, so casting is required.

✅ Best For: Queries that return a single result (e.g., total employees, highest salary).
⛔ Limitation: Cannot handle multiple rows.
23.What is the ADO.NET Entity Framework? How does it simplify database access
compared to raw ADO.NET? Explain.
ADO.NET Entity Framework
ADO.NET Entity Framework provides an abstraction over database operations.
✅ Developers interact with objects and classes instead of writing complex SQL queries.
✅ The framework automatically translates C# objects into relational database
operations.
✅ Supports multiple databases such as SQL Server, MySQL, PostgreSQL, and SQLite.
ADO.NET Entity Framework Simplifies Database Access

✅ Object-Oriented Approach – Developers interact with C# classes instead of tables.

✅ Auto-Generated Queries – EF translates LINQ expressions into SQL.
✅ Migration & Change Tracking – Automatically applies schema changes.
✅ Eliminates Manual Connection Handling – DbContext manages connections internally.
✅ Improves Security – LINQ queries prevent SQL injection vulnerabilities.