Unit 1

1. What is .NET Framework? Explain its architecture in brief.

The .NET Framework is a software development platform developed by Microsoft, designed

to build and run Windows applications. It provides a controlled environment for developing
and running programs written in various languages such as C#, VB.NET, and F#.

Architecture of .NET Framework:

1. Common Language Runtime (CLR):
- The CLR is the execution engine of the .NET Framework, managing program execution,
memory allocation, garbage collection, and security. It provides a common runtime for
multiple languages.

2. Base Class Library (BCL):

- A collection of reusable classes, interfaces, and value types that provide functionalities
like I/O operations, data manipulation, threading, and network communication.

3. Languages:
- .NET supports multiple languages, such as C#, VB.NET, and F#, which follow a unified
coding standard and can be used interchangeably.

4. Application Models:
- Includes various frameworks to create applications, such as:
- Windows Forms (desktop applications)
- ASP.NET (web applications)
- ADO.NET (data access)

5. Interoperability:
- Allows .NET applications to interact with COM components and legacy systems.

6. Common Type System (CTS):

- Ensures that data types are consistent across all .NET languages.

7. Metadata and Assemblies:

- Metadata describes the program structure, while assemblies are compiled code units
that the CLR loads and executes.
8. Security:
- Provides Code Access Security (CAS) and role-based security for robust application
protection.

---

2. What is namespace? Explain with the help of an example.

A namespace in C# is a container that organizes classes, interfaces, and other code

elements into a logical hierarchy, preventing naming conflicts.

Syntax:
namespace NamespaceName {
class ClassName {
public void MethodName() {
Console.WriteLine("Hello, Namespace!");
}
}
}

Example:
using System;

namespace MyApplication {
class MyClass {
public void Greet() {
Console.WriteLine("Welcome to Namespaces!");
}
}
}

class Program {
static void Main() {
MyApplication.MyClass obj = new MyApplication.MyClass();
obj.Greet();
}
}

In this example, the class

MyClass
belongs to the Myapplication namespace, and it is accessed using the fully qualified name.

3. Explain inheritance along with its types.

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a
class (derived/child class) to acquire the properties and behaviors (methods) of another
class (base/parent class). It promotes code reusability and helps in creating hierarchical
class structures.

Types of Inheritance in C#:

1)Single Inheritance:

A child class inherits from one parent class.

Example:-

Class Parent {

Public void Display() {

Console.WriteLine(“This is the Parent class.”);

Class Child : Parent {

Public void Show() {

Console.WriteLine(“This is the Child class.”);

2)Multilevel Inheritance:

A class inherits from another derived class.

Example:-

class GrandParent {

public void GrandParentMethod() {

 Console.WriteLine("This is the Grandparent class.");

class Parent : GrandParent {

public void ParentMethod() {

Console.WriteLine("This is the Parent class.");

class Child : Parent {

public void ChildMethod() {

Console.WriteLine("This is the Child class.");

3)Hierarchical Inheritance:

Multiple child classes inherit from a single parent class.

Example:

Class Parent {

Public void ParentMethod() {

Console.WriteLine(“This is the Parent class.”);

Class Child1 : Parent {

Public void Child1Method() {

Console.WriteLine(“This is the Child 1 class.”);

 }

Class Child2 : Parent {

Public void Child2Method() {

Console.WriteLine(“This is the Child 2 class.”);

4)Multiple Inheritance (through Interfaces in C#):

C# does not support multiple inheritance with classes but allows it through interfaces.

Example:

interface A {

void MethodA();

interface B {

void MethodB();

class Child : A, B {

public void MethodA() {

Console.WriteLine("MethodA from Interface A");

public void MethodB() {

Console.WriteLine("MethodB from Interface B");

 }

4. Explain the difference between value types and reference types.

In C#, data types are categorized into value types and reference types based on how
they store data.

| Aspect | Value Types | Reference Types |

|---------------------------|-----------------------------------------------|---------------------------------
------------|

| Memory Location | Stored in the stack memory. | Stored in the heap

memory. |

| Data Storage | Directly holds data. | Stores a reference to the memory

location. |

| Examples | int, float, bool, struct, enum | class, array, interface, string |

| Assignment | Creates a copy of the data. | Creates a reference to the

data. |

| Performance | Faster, as stack memory is smaller. | Slower, as heap memory

involves overhead. |

| Null Values | Cannot be null unless nullable (int?). | Can store null values.

Example:-

// Value Type

Int x = 10;

Int y = x;

Y = 20; // x remains 10, y is 20 (separate copies)

// Reference Type
 String[] arr1 = { “A”, “B” };

String[] arr2 = arr1;

Arr2[0] = “Z”; // Both arr1 and arr2 point to the same data

5. Write a sample C# program to demonstrate class, object, and method calls.

Program:

using System;

class Car {

// Fields

public string brand;

public string model;

// Method

public void DisplayDetails() {

Console.WriteLine("Car Brand: " + brand);

Console.WriteLine("Car Model: " + model);

class Program {

static void Main() {

// Create an object of Car class

Car myCar = new Car();

 // Assign values to fields

myCar.brand = "Toyota";

myCar.model = "Corolla";

// Call the method

myCar.DisplayDetails();

Output:

Car Brand: Toyota

Car Model: Corolla

6. What is delegate? Explain multicast delegate with an example.

A delegate in C# is a type-safe function pointer that can reference a method with a

specific signature. It allows methods to be passed as arguments and enables dynamic
method invocation.

Multicast Delegate:

A delegate that references multiple methods.

When invoked, all the methods in the invocation list are called in sequence.

Example:

using System;
delegate void Operation(int a, int b);

class Program {

static void Add(int a, int b) {

Console.WriteLine("Addition: " + (a + b));

static void Subtract(int a, int b) {

Console.WriteLine("Subtraction: " + (a - b));

static void Main() {

Operation op;

// Multicast delegate

op = Add;

op += Subtract;

// Invoke multicast delegate

op(10, 5);

}
 Output:

Addition: 15

Subtraction: 5

7. Explain static constructor and copy constructor with examples.

Static Constructor:
- A static constructor initializes static data members of a class or performs a specific
action that needs to be executed only once.
- It is called automatically before the first instance of the class is created or any static
members are accessed.
- Key Features:
1. No parameters are allowed in a static constructor.
2. It cannot be called explicitly.
3. A class can have only one static constructor.

Example (Minimal Code):

class Example {
static int staticValue;

static Example() {
staticValue = 100; // Initialize static field
Console.WriteLine("Static constructor called.");
}
}

Copy Constructor:
- A copy constructor is used to create a new object as a copy of an existing object.
- It takes a parameter of the same type as the class and copies the values of all fields.
- Key Features:
1. Used for deep or shallow copying.
2. Explicitly defined by the programmer.
3. Helpful in copying objects with complex fields, like arrays or references.

Example (Minimal Code):

`

csharp
class Example {
 int value;

public Example(int val) {

value = val; // Constructor
}

public Example(Example obj) { // Copy constructor

value = obj.value;

8. Explain garbage collection and how it works in .NET.

Garbage Collection (GC):

- Garbage collection in .NET is an automatic memory management mechanism that
deallocates memory occupied by unused objects, preventing memory leaks.

How it Works:
1. Generations:
- Objects are categorized into Generations based on their lifespan:
- Gen 0: Short-lived objects (e.g., local variables).
- Gen 1: Medium-lived objects.
- Gen 2: Long-lived objects (e.g., static variables).

2. Memory Allocation:
- When an object is created, it is allocated memory in the managed heap. As the heap
fills up, the garbage collector is triggered.

3. Mark and Sweep Algorithm:

- Mark: GC identifies objects still in use by the application.
- Sweep: Unused objects are removed, and their memory is reclaimed.

4. Compacting:
- GC compacts the memory by moving the remaining objects together to free up
continuous space.

Key Points:
- Automatic: Developers do not need to explicitly deallocate memory.
- Managed Heap: All .NET objects are stored in the heap.
- Performance: GC runs in a separate thread but can temporarily pause application
threads.

Advantages:
- Prevents memory leaks.
 - Simplifies memory management.
- Efficient memory reuse.

Unit 2

1. Write a short note on AdRotator control.

The AdRotator control in ASP.NET is used to display a sequence of advertisements or

images. It rotates the content displayed in the control based on the configuration provided
in an XML file or a database.

### Key Features:

- Rotating Ads: Displays ads dynamically based on specified settings.
- Data Source: Fetches ad details from an XML file or a database table.
- Attributes:
1. ImageUrl: Path to the advertisement image.
2. NavigateUrl: URL to redirect when the ad is clicked.
3. AlternateText: Text displayed when the image cannot load.
4. Keyword: Allows ad filtering based on keywords.
5. Impressions: Specifies the frequency of an ad's display.

### Advantages:
- Reduces manual effort in updating ads.
- Ensures equal distribution of ad impressions.
- Integrates seamlessly with data sources.

---

2. Explain Calendar control.

The Calendar control in ASP.NET allows users to display and select dates. It is commonly
used in scenarios like booking systems, event scheduling, or date selection.

### Key Features:

1. Selectable Date Ranges: Enables selection of specific date ranges.
2. Navigation: Provides navigation to previous and next months.
3. Customization: Allows custom formatting of dates, including day, month, and year.
4. Event Handling: Triggers events like
SelectionChanged
and
DayRender

### Properties:
- SelectedDate: Gets or sets the selected date.
- VisibleDate: Specifies the month and year displayed.
- ShowGridLines: Determines whether to display gridlines.

Advantages:
- Enhances user experience with date selection.
- Can be styled using CSS for better aesthetics.

---

3. What is meant by validation of data? List and explain validation controls in

ASP.NET.

Validation of Data refers to ensuring the input provided by a user is accurate,

complete, and adheres to predefined rules before processing.

### Validation Controls in ASP.NET:

1. RequiredFieldValidator:
- Ensures a field is not left empty.
- Example Use: Mandatory fields like name and email.

2. RangeValidator:
- Validates if a value falls within a specified range (e.g., 1 to 100).

3. CompareValidator:
- Compares the value of one field to another or a constant value.
- Example Use: Password and Confirm Password fields.

4. RegularExpressionValidator:
- Validates input against a regular expression pattern.
- Example Use: Email format validation.

5. CustomValidator:
- Provides a way to define custom logic for validation.
 - Example Use: Verifying a unique username.

6. ValidationSummary:
- Displays all validation errors in a summarized format.

---

4. Write a short note on the Page class.

The Page class is the base class for all ASP.NET web pages. It provides properties,
methods, and events to handle the lifecycle and behavior of an ASP.NET page.

### Key Features:

- Server-Side Processing: Enables interaction with server-side logic.
- State Management: Handles page state using ViewState and other mechanisms.
- Events:
- Page_Load: Triggered when the page is loaded.
- Page_Init: Called during page initialization.
- Methods:
- IsPostBack: Checks whether the page is loaded for the first time or as a result of a
PostBack.
- Validate(): Manually triggers validation of controls.

---

5. Explain ListBox and DropDownList controls.

ListBox Control:
- Used to display a list of items where users can select one or multiple items.
- Key Properties:
- Items: Represents the collection of items.
- SelectionMode: Determines whether multiple selections are allowed.

DropDownList Control:
- Displays a dropdown menu for selecting a single item from a list.
- Key Properties:
- Items: Holds the dropdown items.
- SelectedIndex: Retrieves the selected item's index.

Comparison:
| Feature | ListBox | DropDownList |

|------------------|---------------------------|----------------------------|
| Selection | Single or multiple items | Single item only |

| UI Space | Requires more space | Compact, requires less space |

| Usage | Multiple selection tasks | Single selection dropdowns |

6. Write a short note on ASP.NET page life cycle.

The ASP.NET Page Life Cycle refers to the sequence of steps executed from the creation
of an ASP.NET page to its destruction.

### Key Stages:

1. Page Request:

- Occurs when the browser requests a page from the server.

2. Page Initialization:

- Server initializes the page and its controls.

- Event: Page_Init.

3. Page Load:

- The server processes the Page_Load event to execute user code.

4. PostBack Event Handling:

- Handles any events triggered by controls during a PostBack.

5. Page Rendering:

- The page and its controls are converted into HTML for the browser.

6. Unload:

- Occurs when the page is fully rendered and sent to the client.

- Event: Page_Unload.

7. What is PostBack? Explain the IsPostBack property.

PostBack refers to the process of sending the current state of a web page to the server
and reloading the page with the updated state. It occurs when the user performs an
action like submitting a form or clicking a button.

IsPostBack Property:

- A boolean property of the Page class that checks whether the page is being loaded for
the first time or due to a PostBack.

- Usage:

- IsPostBack = false: Indicates the page is loaded for the first time.

- IsPostBack = true: Indicates the page is being reloaded after a form submission.

8. List and explain the various file types used in an ASP.NET application.
ASP.NET applications consist of various file types that serve specific purposes:

1. .aspx:

- Represents the web page and contains the HTML and server-side script.

2. .aspx.cs / .aspx.vb:

- Code-behind files for handling server-side logic (C# or VB).

3. .config:

- Configuration files (e.g., web.config) that store application settings.

4. .cs / .vb:

- C# or VB.NET files used for custom classes, models, or business logic.

5. .asmx:

- Web service files that define services accessible over HTTP.

6. .master:

- Master pages used for consistent layout across multiple pages.

7. .css:

- Stylesheet files for defining page appearance.

8. .js:

- JavaScript files for client-side scripting.

9. .resx:

- Resource files for storing localized content.

10. Global.asax:

- Application file for handling global events like application start or end.

Unit 3

### 1. What is a Master Page? Explain its features, advantages, and how it works.

Definition:

A Master Page in ASP.NET provides a template for creating a consistent layout for web
pages in an application. It defines placeholders for content, which can be overridden by
content pages.

Features:

1. Consistent Layout: Ensures a uniform look and feel across all pages.

2. Placeholders: Allows sections of the page to be customized.

3. Centralized Changes: Updates in the master page reflect on all associated pages.

4. Design-Time Support: Offers visual design tools in development environments like

Visual Studio.
Advantages:

1. Reusability: The layout can be reused across multiple pages.

2. Ease of Maintenance: Any design changes need to be made only in the master page.

3. Separation of Design and Content: Design elements are in the master page, and
content is in content pages.

4. Improved Productivity: Speeds up development by avoiding repetitive tasks.

How It Works:

1. Create a Master Page (.master file) containing static elements and placeholders.

2. Add Content Pages that inherit the layout of the Master Page.

3. Use ContentPlaceHolder controls in the Master Page and Content controls in the
content pages.

Example:

_Master Page (Site.master)_

<!DOCTYPE html>

<html>

<head>

<title>Master Page</title>

</head>

<body>

<header>Header Section</header>

<main>
 <asp:ContentPlaceHolder ID=”MainContent”
runat=”server”></asp:ContentPlaceHolder>

</main>

<footer>Footer Section</footer>

</body>

</html>

_Content Page (Default.aspx)_

<%@ Page MasterPageFile=”Site.master” %>

<asp:Content ID=”Content1” ContentPlaceHolderID=”MainContent” runat=”server”>

<h1>Welcome to the Home Page!</h1>

</asp:Content>

### 2. What are Themes? Explain how to create and use themes in a website.

Definition:

Themes in ASP.NET are used to define a consistent look and feel for web pages using
CSS, skin files, and images.

Key Components:

1. **Skin Files (.skin)**: Define styles for server controls.CSS Fileses**: Style sheets for
page layout and design.Imageses**: Used as background or UI
elementAdvantages:s:**Consistencycy**: Ensures a uniform appearance across the
website.Customizablele**: Themes can be dynamically changed at runtime.Separation
of Concernsns**: Keeps design elements separate from functionalitHow to Create and
Use Themes:s:**Create a Theme Folderer**: Inside the App_Themes directory.Add
Theme Elementsts**:
 - Create .skin files for controls.

- Include .css files for layout.

- Add images for visual elements.Apply the Thememe**:

- Set the Theme property in the Web.config file.

- Or specify the Theme attribute in the Page directivExample:e:**

_Creating a Theme (App_Themes/MyTheme)Button.skinin**:

<asp:Button runat=”server” BackColor=”LightBlue” ForeColor=”Black” />

- **style.css**:

Body {

Font-family: Arial, sans-serif;

Background-color: #f0f0f0;

_Apply the Theme in Web.config_

<configuration>

<system.web>

<pages theme=”MyTheme” />

</system.web>

</configuration>

### 3. Explain exception handling mechanism with syntax and example.

Definition:
Exception handling in ASP.NET is a mechanism to detect and handle runtime errors,
ensuring smooth execution of the application. It prevents the application from crashing
due to unexpected issues.
Mechanism:
1. **
try
Block**: Code that might throw an exception is placed in the
try
block.
2. **
catch
Block**: Handles exceptions that occur in the
try
block.
3. **
finally
Block**: Optional; executes code regardless of whether an exception occurred or not.
4. **
throw
Statement**: Re-throws the exception for furthSyntax:ng.

**Syntax:**
try {
// Code that might throw an exception
} catch (ExceptionType ex) {
// Handle exception
} finally {
// Cleanup code (optional)
}

**Example:**
try {
int a = 10, b = 0;
int result = a / b; // Division by zero exception
} catch (DivideByZeroException ex) {
Console.WriteLine("Error: " + ex.Message);
} finally {
Console.WriteLine("Execution completed.");
}

**Advantages:**
1. Prevents abrupt termination of the program.
2. Improves code reliability and user experience.
3. Helps log errors for What is ViewState in ASP.NET? Explain its advantages and
disadvantages.geDefinition:ages.**

**Definition:**
ViewState is a client-side state management technique used in ASP.NET to persist the state
of controls between postbacks. It stores the data in a hidHow It Works:page.

**How It Works:**
1. ASP.NET serializes the state of controls into a string and stores it in a hidden
__VIEWSTATE
field.
2. When the page is posted back, ASP.NET deserializes the string to
restoAdvantages:statNo Server Dependency**No Server Dependency**: Data is stored
on the client side, reducAutomaticerhead.
2. **Automatic**: Managed by ASP.NET withSecurityal code.
3. **Security**: Data is Base64-encodedDisadvantages:ted.Performance
Overhead**Performance Overhead**: Large ViewState can increase page size anSecurity
Risksg.
2. **Security Risks**: If not encrypted, data can be interceptClient Dependency3. **Client
Dependency**: Data is stored on the client, increasing reliance on browseWrite a short
note on cookies in ASP.NET (including persistent cookies).g Definition:ies).**

**Definition:**
Cookies are small pieces of data stored on the client side (browser) to maintain statTypes
of Cookies:.

*Session Cookies*
1. **Session Cookies**: Temporary cookies that are deleted when thPersistent Cookies.
**Persistent Cookies**: Stored on the client’s device forCreating a Cookie:

**Creating a Cookie:**
HttpCookie myCookie = new HttpCookie("UserName", "John");
myCookie.Expires = DateTime.Now.AddDays(7); // Persistent for 7 days
Response.Cookies.Add(myCookie);

**Reading a Cookie:**
HttpCookie myCookie = Request.Cookies["UserName"];
if (myCookie != null) {
string userName = myCookie.Value;
}
**Advantages:**
1. Simple to implement.
2. Persistent cookDisadvantages:erm storage.

**Disadvantages:**
1. Limited size (4KB).
2. Can be Explain Query Strings as a state management technique in
ASP.NET.naDefinition:e in ASP.NET.**

**Definition:**
Query strings are a state management technique where data is appended Structure:key-
value pairs.

**Structure:**
http://example.com/page.aspx?key1=value1&key2=value2

**Advantages:**
1. Simple and easy to useDisadvantages:ourcSecurity

**Disadvantages:**
1. **Security**: Data is visible in tLimited Sizee tampered with.
2. **Limited Size**: Only smExample:of data can be passed.

**Example:**
_Sending Data:_
Response.Redirect("Page2.aspx?Name=John&Age=25");

_Receiving Data:_
string name = Request.QueryString["Name"];
string age = Request.QueryString["Age"];

---

### 7. **What is debugging? Explain the process of debugging in detail.**

Definition:
Debugging is the process of identifying and fixing errors (bugs) in the application code to
ensure correct functionality.

Process:
1. Understanding the Problem: Analyze the reported issue or unexpected behavior.
2. Set Breakpoints: Pause execution at specific lines to inspect variable values.
3. Step Through Code: Execute the code line by line to locate the issue.
4. Inspect Variables: Check the state of variables and objects.
5. Fix Errors: Modify the code to resolve the bug.
6. Test the Fix: Re-run the application to ensure the issue is resolved.

Tools for Debugging in ASP.NET:

1. Visual Studio Debugger: Includes breakpoints, watch windows, and call stack.
2. Trace Logs: Use the
Trace
object to log messages.
3. Browser Developer Tools: For debugging client-side code like JavaScript.

Example (Using Breakpoints):

1. Add a breakpoint in Visual Studio by clicking the left margin next to a line of code.
2. Run the application in debug mode (
F5
).
3. Inspect values in the Watch or Immediate window.

---

### 8. What are state management techniques in ASP.NET?

Definition:
State management in ASP.NET refers to the techniques used to maintain the state of a web
application and its controls across requests.

Types of State Management:

1. Client-Side Techniques:
- ViewState: Stores control state in a hidden field.
- Cookies: Stores small amounts of data on the client.
- Query Strings: Passes data via the URL.
- Hidden Fields: Stores data in a hidden input field.
2. Server-Side Techniques:
- Session State: Stores data for each user session on the server.
- Application State: Stores data shared across all users.
- Database: Stores data persistently in a database.

Factors to Consider:
1. Performance: Choose a method that minimizes server/client overhead.
2. Security: Avoid exposing sensitive data in ViewState or Query Strings.
3. Scope: Session state is ideal for per-user data, while Application state is better for global
data.

Unit 4

Unit 4

### 1. Explain ADO.NET Data Provider Model with a diagram.

Definition:
The ADO.NET Data Provider Model is a collection of classes that enable interaction
between an application and a database. It provides a way to connect, execute commands,
and retrieve data from a database.

Key Components:
1. Connection: Establishes a connection to the database (e.g.,
SqlConnection
for SQL Server).
2. Command: Executes SQL queries and stored procedures (e.g.,
SqlCommand
).
3. DataReader: Retrieves data in a forward-only, read-only manner.
4. DataAdapter: Bridges the gap between a
DataSet
and the database for disconnected access.

Diagram:
Application
|
V
Data Provider (e.g., SqlClient)
|
---------------------------
| Connection |
| Command |
| DataReader/DataAdapter|
---------------------------
|
V
Database

Advantages:
1. Efficient and optimized for specific databases.
2. Supports both connected and disconnected data access.
3. Allows transaction management.

---

### 2. Differentiate between DataSet and DataReader in ADO.NET.

| Aspect | DataSet | DataReader |

|-------------------|--------------------------------------------|----------------------------------------|
| Nature | Disconnected | Connected |
| Access | Stores data in memory | Forward-only, read-only access |
| Performance | Slower due to memory usage | Faster due to direct access |
| Features | Supports multiple tables, relationships | Fetches one record at a time |
| Use Case | Suitable for large, complex data handling | Suitable for quick, lightweight
access |
| Example |
SqlDataAdapter
with
DataSet
|
SqlDataReader
|

---

### 3. Explain SqlDataSource control in ASP.NET.

Definition:
The
SqlDataSource
control is an ASP.NET server control that allows developers to connect to a database and
perform CRUD (Create, Read, Update, Delete) operations without writing explicit ADO.NET
code.

Features:
1. Declarative Data Access: No need for manual database connection or commands.
2. Supports SQL Statements: Can execute SELECT, INSERT, UPDATE, DELETE queries.
3. Data Caching: Improves performance by caching results.
4. Filtering: Supports parameterized queries for filtering data.

Example:
<asp:SqlDataSource
ID="SqlDataSource1"
runat="server"
ConnectionString="<%$ ConnectionStrings:MyDB %>"
SelectCommand="SELECT * FROM Employees">
</asp:SqlDataSource>

Advantages:
1. Simplifies data binding for controls like GridView.
2. Reduces boilerplate ADO.NET code.

---

### 4. What is a GridView control? Explain its features (e.g., sorting, paging, editing)
and give an example.

Definition:
The
GridView
control in ASP.NET is used to display data in a tabular format with built-in features for
sorting, paging, and editing.

Features:
1. Sorting: Allows sorting columns by clicking the column headers.
2. Paging: Divides data into pages with navigation controls.
3. Editing and Deleting: Supports inline editing and deletion of records.
4. Customizable: Template columns for custom layouts.

Example:
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
AllowPaging="true" AllowSorting="true" DataSourceID="SqlDataSource1">
</asp:GridView>
<asp:SqlDataSource
ID="SqlDataSource1"
runat="server"
ConnectionString="<%$ ConnectionStrings:MyDB %>"
SelectCommand="SELECT * FROM Employees">
</asp:SqlDataSource>

---

### 5. What is Data Binding? Explain its types and give examples.

Definition:
Data binding is the process of connecting a data source to UI controls to display and
interact with data.

Types of Data Binding:

1. Simple Data Binding: Binds controls like
TextBox
and
Label
to a single data value.
- Example:

TextBox1.Text = dataSet.Tables[0].Rows[0]["Name"].ToString();

2. Complex Data Binding: Binds controls like

GridView
and
DropDownList
to a data collection.
- Example:
 <asp:GridView DataSourceID="SqlDataSource1"
runat="server"></asp:GridView>

Advantages:
1. Simplifies UI updates.
2. Reduces the amount of boilerplate code.

---

### 6. Differentiate between FormView and DetailsView controls in ASP.NET.

| Aspect | FormView | DetailsView |

|--------------------|---------------------------------------|---------------------------------------|
| Display | Displays one record at a time | Displays one record in a tabular format |
| Templates | Fully customizable with templates | Uses predefined table layout |
| Editing | Allows inline editing and inserting | Supports editing and deletion |
| Use Case | Advanced customization needed | Simple record display |

---

### 7. Write and explain C# code to insert or display data using GridView and a
database.

Code to Display Data:

protected void Page_Load(object sender, EventArgs e) {
if (!IsPostBack) {
string connStr = "your_connection_string";
using (SqlConnection conn = new SqlConnection(connStr)) {
SqlCommand cmd = new SqlCommand("SELECT * FROM Employees", conn);
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
GridView1.DataSource = reader;
GridView1.DataBind();
}
}
}

Explanation:
1. Establish a connection using
SqlConnection
.
2. Execute a query using
SqlCommand
.
3. Bind the result to
GridView
for display.

---

### 8. Explain ExecuteNonQuery, ExecuteScalar, and ExecuteReader methods with

examples.

1. ExecuteNonQuery:
- Definition: Executes SQL commands that do not return data (e.g., INSERT, UPDATE,
DELETE).
- Example:

SqlCommand cmd = new SqlCommand("DELETE FROM Employees WHERE ID=1", conn);

int rowsAffected = cmd.ExecuteNonQuery();

2. ExecuteScalar:
- Definition: Executes a query and returns a single value (e.g., aggregate functions like
COUNT).
- Example:

SqlCommand cmd = new SqlCommand("SELECT COUNT(*) FROM Employees", conn);

int count = (int)cmd.ExecuteScalar();

3. ExecuteReader:
- Definition: Executes a query and returns a
SqlDataReader
for reading data row by row.
- Example:

SqlCommand cmd = new SqlCommand("SELECT * FROM Employees", conn);

SqlDataReader reader = cmd.ExecuteReader();
Unit 5

### 1. What is XML? List its features and various XML classes used in ASP.NET.

Definition:
XML (eXtensible Markup Language) is a markup language used to store, transport, and
structure data in a hierarchical and self-descriptive format.

Features of XML:
1. Platform Independent: XML data can be used across different platforms.
2. Self-Descriptive: The structure and data are embedded within XML tags.
3. Supports Hierarchical Data: Data can be organized in parent-child relationships.
4. Customizable Tags: Users can define their own tags based on application requirements.
5. Human and Machine Readable: Easy to understand for humans and process by
machines.
6. Data Interchange: Facilitates data exchange between heterogeneous systems.
7. Extensible: Provides the flexibility to define complex data structures.

XML Classes in ASP.NET:

1. XmlReader: Reads XML data in a forward-only, read-only mode.
2. XmlTextReader: Reads XML data from a file, stream, or URL.
3. XmlWriter: Writes XML data to a stream or file.
4. XmlTextWriter: Provides methods to write XML in a text-based format.
5. XmlDocument: Represents an XML document, allowing DOM (Document Object
Model)-based access.
6. XmlNode: Represents a single node in an XML document.
7. XPathNavigator: Navigates and evaluates XPath expressions in XML documents.

---

### 2. Explain XmlTextReader and XmlTextWriter with examples.

XmlTextReader:
- It is used to read XML data in a forward-only, streaming manner.

Example:
XmlTextReader reader = new XmlTextReader("employees.xml");
while (reader.Read())
{
 if (reader.NodeType == XmlNodeType.Element && reader.Name == "Name")
{
Console.WriteLine("Employee Name: " + reader.ReadString());
}
}
reader.Close();

XmlTextWriter:
- It is used to write XML data to a file, stream, or memory.

Example:
XmlTextWriter writer = new XmlTextWriter("employees.xml", Encoding.UTF8);
writer.WriteStartDocument();
writer.WriteStartElement("Employees");
writer.WriteStartElement("Employee");
writer.WriteElementString("Name", "John Doe");
writer.WriteElementString("ID", "123");
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();

---

### 3. Define Authentication and Authorization. Explain their types with examples.

Authentication:
- The process of verifying the identity of a user.
- Ensures that only legitimate users can access the system.
- Types:
1. Windows Authentication: Uses Windows accounts for authentication.
2. Forms Authentication: Uses a login page to authenticate users.
3. Passport Authentication: Centralized authentication service provided by Microsoft.
4. Token-Based Authentication: Uses tokens for user identity verification.

Authorization:
- The process of determining what an authenticated user is allowed to do.
- Ensures resource access control.
- Types:
1. Role-Based Authorization: Grants access based on user roles.
2. Policy-Based Authorization: Grants access based on custom policies.
3. Claims-Based Authorization: Based on user claims.
**Example of Authentication and Authorization in
web.config
:**
<authentication mode="Forms">
<forms loginUrl="Login.aspx" />
</authentication>
<authorization>
<allow roles="Admin" />
<deny users="?" />
</authorization>

---

###Explain Windows Authentication and its implementation in

ASP.NET.T.Definition:n:**
Windows Authentication uses the Windows operating system to authenticate users based
on their Windows credentialImplementation Steps:s:**
1. Set the authentication mode to
Windows
in
web.config
:

<authentication mode="Windows" />

2. Restrict access to specific users or groups:

<authorization>
<allow users="Domain\Username" />
<deny users="*" />
</authorization>

3. Configure IIS to use Windows AuthenticatioAdvantages:s:**

1. No need for custom authentication code.
2. Seamless integration with Active Directory.
3. High security.
---###What is AJAX in ASP.NET? Explain UpdatePanel and ScriptManager
controls.s.Definition:n:**

AJAX (Asynchronous JavaScript and XML) in ASP.NET enables asynchronous

communication between the client and server, allowing parts of a web page to update
without refreshing the entire pagUpdatePanel:l:**

- A control that allows partial page updates.

- Only the content inside the UpdatePanel is refreshed.

- Example:

<asp:UpdatePanel runat=”server”>

<ContentTemplate>

<asp:Label ID=”Label1” runat=”server” Text=”Initial”></asp:Label>

<asp:Button ID=”Button1” runat=”server” Text=”Click Me” OnClick=”Button1_Click”

/>

</ContentTemplate>

</asp:UpdatePanel>

ScriptManager:

- A control required to manage AJAX requests.

- It registers and coordinates scripts for controls in the page.

What is the purpose of UpdateProgress Control in AJAX? Explain with an

example.amPurpose:rpose:**

- Displays a progress indicator while an AJAX request is being procExample:ample:**

<asp:ScriptManager ID=”ScriptManager1” runat=”server” />

<asp:UpdatePanel ID=”UpdatePanel1” runat=”server”>

<ContentTemplate>
 <asp:Button ID=”Button1” runat=”server” Text=”Click Me” />

</ContentTemplate>

</asp:UpdatePanel>

<asp:UpdateProgress ID=”UpdateProgress1” runat=”server”>

<ProgressTemplate>

<img src=”loading.gif” alt=”Loading…” />

</ProgressTemplate>

</asp:UpdateProgress>

Explain Timer Control and its use in creating real-time web applications.tiDefinition:ition:**

The Timer control in ASP.NET AJAX executes server-side code at specified intervals without
requiring full-page refrUse Case: Case:**

- Real-time applications such as stock updates, news feeds, or chat

syExample:ample:**

<asp:ScriptManager ID=”ScriptManager1” runat=”server” />

<asp:UpdatePanel ID=”UpdatePanel1” runat=”server”>

<ContentTemplate>

<asp:Label ID=”Label1” runat=”server” Text=”Time”></asp:Label>

</ContentTemplate>

<Triggers>

<asp:AsyncPostBackTrigger ControlID=”Timer1” EventName=”Tick” />

</Triggers>

</asp:UpdatePanel>

<asp:Timer ID=”Timer1” runat=”server” Interval=”1000” OnTick=”Timer1_Tick” />

Code-Behind:

Protected void Timer1_Tick(object sender, EventArgs e)

{
 Label1.Text = DateTime.Now.ToString();

Write code to save and read Employee Data in XML format using XML classes.L Save
Data:Save Data:**

XmlTextWriter writer = new XmlTextWriter(“employees.xml”, Encoding.UTF8);

Writer.WriteStartDocument();

Writer.WriteStartElement(“Employees”);

Writer.WriteStartElement(“Employee”);

Writer.WriteElementString(“Name”, “John Doe”);

Writer.WriteElementString(“ID”, “123”);

Writer.WriteEndElement();

Writer.WriteEndElement();

Writer.Close();

Read Data:

XmlTextReader reader = new XmlTextReader(“employees.xml”);

While (reader.Read())

If (reader.NodeType == XmlNodeType.Element && reader.Name == “Name”)

Console.WriteLine(“Employee Name: “ + reader.ReadString());

Reader.Close();

### 9. Explain the working of AutoCompleteExtender in ASP.NET AJAX Definition:.

Definition:

The AutoCompleteExtender is a control that provides auto-suggestions to users as they

Working:xtbox.

Working:

1. The extender sends requests to a web service or page method.

2. The server returns a list of suggestions.

3. The extender displays suggestions Example:xtbox.

Example:

<asp:TextBox ID=”TextBox1” runat=”server” />

<ajaxToolkit:AutoCompleteExtender

TargetControlID=”TextBox1”

ServiceMethod=”GetSuggestions”

MinimumPrefixLength=”1”

Runat=”server” />

Code-Behind:

[WebMethod]

Public static string[] GetSuggestions(string prefixText)

Return new string[] { “John”, “Jane”, “Jake” }.Where(s => s.StartsWith(prefixText)).ToArray();

### **10. How is the web.config file used to implement forms authentication in
ASP.NET?Definition:n:**
Forms authentication is an authentication mechanism in ASP.NET that validates user
credentials against a custom database or other data store, and uses a cookie to maintain
the user’s authentication state.

Steps to Implement Forms Authentication:

1. **Enable Forms Authentication in web.config:**

In the web.config file, set the authentication mode to Forms. Specify the login page URL
and session timeout. The login page is where unauthenticated users will be redirected.

Example:e:**

<authentication mode=”Forms”>

<forms loginUrl=”Login.aspx” timeout=”30” />

</authentication>

- mode=”Forms”: Specifies that forms-based authentication will be used.

- loginUrl=”Login.aspx”: The page where users will be redirected for authentication.

- timeout=”30”: Specifies the session timeout in minutes.

Configure Authorization Rules:s:**

Use the <authorization> element to restrict access to certain pages or directories. The
rules determine which users can access specific resources.

Example:e:**

<authorization>

<deny users=”?” /> <!—Denies access to anonymous users →

<allow users=”*” /> <!—Allows access to all authenticated users →

</authorization>
 - deny users=”?”: Denies access to unauthenticated (anonymous) users.

- allow users=”*”: Allows access to all authenticated users.

2. **Create a Login Page (Login.aspx):**

The login page collects the user’s credentials (username and password). Validate these
credentials against a database or any data source. If the credentials are valid, use the
FormsAuthentication class to create an authentication ticket.

**Example Code for Login.aspx:**

Protected void LoginButton_Click(object sender, EventArgs e)

String username = txtUsername.Text;

String password = txtPassword.Text;

// Example: Validate user credentials (replace with database validation)

If (username == “admin” && password == “password123”)

// Create the authentication ticket and redirect

FormsAuthentication.RedirectFromLoginPage(username, true);

Else

lblMessage.Text = “Invalid username or password.”;

}
 3. **Redirect to Login Page Automatically:**

If an unauthenticated user tries to access a protected resource, they will automatically be

redirected to the loginUrl specified in the web.config file.

4. **Store User Authentication State:**

When a user logs in successfully, ASP.NET issues a forms authentication ticket (a cookie)
to track the user’s authentication state. This cookie is sent with every subsequent request
to ensure the user remLogout Implementation (Optional):tation (Optional):**

To log out a user, call the FormsAuthentication.SignOut() method and redirect the user to
the login pagExample Logout Code:ample Logout Code:**

Protected void LogoutButton_Click(object sender, EventArgs e)

FormsAuthentication.SignOut();

Response.Redirect(“Login.aspx”);

**Advantages of ForCustomizablen:**

1. **Customizable**: Developers can design a login page according to appliIntegration

with Cookiestegration with Cookies**: Uses cookies to maintain the uPlatform
Independent**Platform Independent**: Works with any data source for credential
validation (e.g., databases, APIs).

**Key Sections in web.config for Forms Authentication:**

<system.web>

<authentication mode=”Forms”>

<forms loginUrl=”Login.aspx” timeout=”30” />

 </authentication>

<authorization>

<deny users=”?” />

<allow users=”*” />

</authorization>

</system.web>

**Summary:**

Forms authentication in ASP.NET is implemented using the web.config file to define

authentication and authorization rules. The login page handles user credential validation,
and a cookie is issued to maintain the authentication state. Proper configuration of the
web.config ensures secure access control in web applications.