Web Technology — ASP.
NET Exam Notes | Wireless PSI Exam Preparation
🌐 WEB TECHNOLOGY
[Link] & Visual Studio — Complete Exam Notes
Wireless PSI Exam | Includes Theory · PYQs · Tricky Points · Notes
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Page 1 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
UNIT 1 — Web Technology Fundamentals
1.1 Web Application vs Webpage
Key Definitions (Frequently Asked in Exams)
Web Application Webpage
Dynamic, interactive system (e.g., Gmail, Static or semi-static document displayed
online banking) in browser
Executes logic on client/server side Primarily presents information
Uses [Link], PHP, JSP, [Link] etc. HTML, CSS, JS — no server-side logic
needed
Has state, sessions, databases Stateless by default
Example: e-commerce site, email portal Example: company 'About Us' HTML
page
📝 NOTE — Remember for Exams
All Web Applications contain webpages, but not all webpages form a Web
Application.
A webpage is a single document; a web application is a collection of webpages with
business logic.
1.2 Components of a Web Application
A web application is built from several interacting components:
Component Role [Link] Example
Web Server Handles HTTP IIS (Internet Information
requests/responses Services)
Application Server Executes business logic [Link] runtime / CLR
Database Server Stores/retrieves persistent data MS SQL Server, MySQL
Web Browser Renders UI, sends requests Chrome, Firefox, Edge
(Client)
Middleware Connects components [Link], HTTP Modules
Web Forms / MVC UI layer of application [Link] Web Forms,
Page 2 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Component Role [Link] Example
MVC
⚠️TRICKY POINT
IIS (Internet Information Services) is NOT a component of [Link] itself; it is the
Web Server that HOSTS [Link] applications.
CLR (Common Language Runtime) is the execution engine — always mention it
when explaining how [Link] runs code.
1.3 Client–Server Architecture
Client–Server Architecture is the backbone of all web applications.
Client Side Server Side
Runs in user's browser Runs on the web/application server
Languages: HTML, CSS, JavaScript Languages: C#, [Link], PHP, Java
Cannot access server resources directly Accesses databases, files, business logic
Fast response for UI changes Slower (network round-trip required)
Validation: client-side validation Validation: server-side validation (more
secure)
How a Request–Response Cycle Works:
1 Step 1: User types URL → Browser sends HTTP GET request to server
2 Step 2: DNS resolves domain to IP address
3 Step 3: Web server (IIS) receives request
4 Step 4: [Link] runtime processes the request (executes .aspx code-behind)
5 Step 5: Data fetched from database if needed (via [Link] / EF)
6 Step 6: HTML response generated and sent back to browser
7 Step 7: Browser renders HTML/CSS/JS — user sees the page
📌 PYQ — 2-Mark Question
Q: "Differentiate between client-side and server-side scripting." (2 Marks)
Answer Tip: Client-side = runs in browser (JS), no server needed, less secure.
Server-side = runs on server (C#/VB), accesses DB, more secure, generates HTML
Page 3 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
dynamically.
UNIT 2 — Classic ASP vs [Link]
2.1 What is Classic ASP (Active Server Pages)?
• Introduced by Microsoft in 1996
• Server-side scripting using VBScript or JScript
• Code and HTML mixed in same .asp file (spaghetti code)
• No compilation — interpreted line by line (slow)
• No built-in support for OOP
• No separation of concerns
2.2 Features of [Link]
[Link] was introduced in 2002 as part of .NET Framework. Key features:
Feature Description
Compiled Code Code compiled to MSIL then JIT-compiled — much
faster than interpreted ASP
Language Independent Supports C#, [Link], J# — multiple languages in
same project
Object-Oriented Full OOP support: classes, inheritance, encapsulation,
polymorphism
Code-Behind Model Separation of HTML (markup) and logic (code-
behind .cs/.vb file)
Rich Controls (Web Server-side controls like GridView, TextBox, Button
Controls) with events
State Management ViewState, Session, Cookies, Application state built-in
Built-in Security Forms Authentication, Windows Authentication, Role-
based security
[Link] Integration Seamless database connectivity via DataSet,
DataAdapter, SqlConnection
Web Services Easy creation of XML Web Services / WCF / Web API
MVC Support [Link] MVC for Model-View-Controller pattern
(testable, clean code)
Caching Page output caching, fragment caching, data caching
for performance
Page 4 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Feature Description
CLR Benefits Automatic memory management (garbage collection),
exception handling
2.3 Differences: [Link] vs Classic ASP
Classic ASP [Link]
Interpreted (line by line) Compiled (faster execution)
VBScript / JScript only C#, [Link], F# etc.
No OOP support Full OOP (classes, inheritance)
Code and HTML mixed (.asp file) Code-Behind model (.aspx + .cs/.vb)
No event model Rich event-driven programming model
Manual state management Built-in ViewState, Session, Application
No Web Controls Rich server-side Web Controls
(GridView, etc.)
No built-in security framework Forms Auth, Windows Auth, Role
Management
Poor scalability High scalability (CLR, caching, pooling)
No IntelliSense support Full IntelliSense in Visual Studio
File extension: .asp File extension: .aspx
(and .[Link] / .[Link])
📌 PYQ — 5 Mark Question
Q: "Compare Classic ASP with [Link]. (5 Marks)" — Very common exam
question!
Answer Strategy: Write the table above (any 8 points) + add 1-2 lines intro about
each. End with: "[Link] is a complete rewrite, not an upgrade of Classic ASP."
⚠️TRICKY POINT — Common Mistake
Students often write "[Link] is an upgraded version of Classic ASP" — THIS IS
WRONG.
[Link] is a COMPLETE REWRITE from scratch. It shares only the name and
concept. Mention this in your exam answer.
Page 5 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
UNIT 3 — Introduction to Visual Studio IDE
3.1 What is Visual Studio?
Visual Studio (VS) is Microsoft's primary Integrated Development Environment (IDE) for
developing .NET applications including [Link] Web Applications.
• Current version: Visual Studio 2022 (for .NET 6/7/8+)
• Also available: Visual Studio Code (lightweight, cross-platform)
• For [Link]: Visual Studio Community / Professional / Enterprise editions
3.2 Parts of Visual Studio IDE — Detailed
The IDE has several key components you must know for the exam:
A. Start Page
Purpose First screen shown when VS opens
Contents Provides: Recent Projects, New Project, Open Project
options
News Feed Contains news/updates feed (can be disabled)
Resources Quick access to development resources and templates
Pinned Projects Shows pinned/favourite projects for fast access
B. The Menu System
Menu Key Options Exam Relevance
File New Project, Open Project, Save Creating/saving web projects
All
Edit Find & Replace, IntelliSense, Code editing features
Undo/Redo
View Solution Explorer, Toolbox, Opening IDE panels
Properties, Output
Project Add New Item (Web Form, Class), Adding pages/components
Add Reference
Build Build Solution (F6), Rebuild, Clean Compiling the application
Debug Start Debugging (F5), Breakpoints, Running & testing app
Watch window
Page 6 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Menu Key Options Exam Relevance
Tools Options, Extensions & Updates, IDE configuration
NuGet
Window Arrange windows, split screen Workspace management
C. Toolbars
Toolbars provide quick access to frequently used commands. Important toolbars:
• Standard Toolbar — New, Open, Save, Cut, Copy, Paste, Undo, Redo, Debug
• Debug Toolbar — Start (F5), Stop, Pause, Step Over/Into/Out, Breakpoints
• HTML Source Editing Toolbar — Format, validate HTML source
• Layout Toolbar — Align, spacing of web controls on design surface
• Web Formatting Toolbar — Font, size, color for web form design
📝 NOTE
Toolbars can be customized: Right-click on toolbar area → Add/Remove buttons.
You can also dock/undock toolbars by dragging them.
D. New Project Dialog Box
Accessed via: File → New → Project (Ctrl + Shift + N)
Language Filter Left Panel: Language/Framework filter (C#, VB, F#)
Templates Center: Project Templates ([Link] Web App, MVC,
Web API, Empty)
Project Name Project Name: Name of your project/solution
Location Location: Directory where files will be saved
Solution Name Solution Name: Container that holds one or more
projects
Framework Framework Selector: Target .NET Framework version
Version Note .NET 6/7/8 — Modern cross-platform; .NET Framework
4.x — Windows only
E. Graphical Designer (Design View)
The Design View (WYSIWYG editor) of an [Link] Web Form:
• Drag-and-drop interface to add Web Controls to the page
• Shows visual representation of the .aspx page layout
• Controls from Toolbox can be dragged onto Design Surface
• Properties window shows selected control's properties
Page 7 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
• Switch between Design / Split / Source views using tabs at bottom
• Design view renders approximate browser appearance
⚠️TRICKY POINT
Design View is NOT a perfect browser preview — final rendering may differ slightly.
Design view uses an embedded rendering engine, not a real browser. Always test in
actual browser (F5).
F. Code Designer (Code-Behind)
The Code-Behind model is one of [Link]'s most important features:
.aspx File (Markup/View) Code-Behind File (.[Link] or .[Link])
Contains HTML + Server Control Contains C# or [Link] logic
declarations
e.g., <asp:Button ID="btn1" e.g., protected void btn1_Click(...) { }
runat="server" />
Designer-editable (visual) Programmer writes business logic here
Defines UI structure Handles events, database calls,
processing
G. Other Important IDE Components
Component Description
Solution Explorer Tree view of all files in project: .aspx, .cs, [Link], etc.
(View → Solution Explorer or Ctrl+Alt+L)
Toolbox Contains all Web Controls, HTML controls, data controls.
Drag onto design surface. (View → Toolbox or Ctrl+Alt+X)
Properties Window Shows properties of selected control/file. Change ID, Text,
Color, Size etc. (F4 or View → Properties Window)
Output Window Shows build results, errors, warnings, debug output. (View
→ Output)
Error List Lists syntax errors, warnings, messages with line numbers.
Double-click to jump to error.
IntelliSense Auto-complete for code, shows available methods,
parameters. Triggered by typing or Ctrl+Space.
Class View Shows all classes and members in the project hierarchy.
Server Explorer Connect to databases, servers, services. Drag tables onto
Page 8 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Component Description
forms to create data controls.
📌 PYQ — 4 Mark Question
Q: "Explain the various parts of Visual Studio IDE." (4 Marks)
Answer Tip: Describe: (1) Start Page (2) Menu Bar (3) Toolbars (4) Toolbox (5)
Solution Explorer (6) Properties Window (7) Design/Code View. Write 2 lines each =
easy 4 marks.
UNIT 4 — Creating a Web Application in [Link]
4.1 Steps to Create a New [Link] Web Project
Step-by-step process — memorize this sequence!
# Step
1 Open Visual Studio → Click 'Create a new project' from Start Page
2 In New Project Dialog: select '[Link] Web Application (.NET Framework)' or
'[Link] Core Web App'
3 Enter Project Name, choose Location (directory), and Solution Name
4 Select target .NET Framework version (e.g., .NET Framework 4.8 or .NET 6)
5 Click 'Create' — VS creates project with default files
6 Project structure created: [Link], [Link], App_Data folder etc.
7 Design view opens — drag controls from Toolbox onto the form
8 Double-click a button to auto-generate event handler in code-behind
9 Write C# logic in code-behind (.[Link]) file
10 Press F5 (or Debug → Start Debugging) to run in browser
11 IIS Express launches automatically and opens app in default browser
4.2 [Link] Project Structure — Important Files
File/Folder Purpose
[Link] Default home page — HTML + [Link] server controls
markup
[Link] Code-behind (C#): event handlers and business logic
Page 9 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
File/Folder Purpose
[Link].c Auto-generated: declares control variables (don't edit
s manually)
[Link] XML config file: DB connection strings, authentication
settings, app settings
[Link] Application-level event handler (Application_Start,
Session_Start, etc.)
App_Data/ Folder for local database files (.mdf), XML data files
App_Code/ Folder for shared classes, business logic accessible across
project
Bin/ Compiled DLL files of the project (generated during build)
Content/ CSS files and static assets
Scripts/ JavaScript files (jQuery, Bootstrap JS)
📝 NOTE — [Link] is CRITICAL
[Link] is an XML file that controls the entire [Link] application's configuration.
Key settings: <connectionStrings>, <authentication>, <authorization>, <compilation
debug='true'>, <customErrors>.
Modifying [Link] does NOT require recompilation — changes take effect
immediately.
4.3 Simple 'Hello World' [Link] Web Application
Design ([Link] — Source View):
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="[Link]"
Inherits="[Link]" %>
<!DOCTYPE html>
<html> <head><title>My First [Link] Page</title></head>
<body>
<form id="form1" runat="server">
<asp:Label ID="lblMsg" runat="server" Text="Welcome!"/>
<asp:Button ID="btnHello" runat="server" Text="Click Me"
OnClick="btnHello_Click"/>
</form> </body> </html>
Code-Behind ([Link]):
using System;
using [Link];
namespace MyWebApp {
public partial class Default : Page {
protected void Page_Load(object sender, EventArgs e) {
if (!IsPostBack) { [Link] = "Hello, World!"; }
Page 10 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
}
protected void btnHello_Click(object sender, EventArgs e) {
[Link] = "Button clicked at: " + [Link]();
}
}
}
📌 PYQ — 3 Mark Question
Q: "What is IsPostBack? Why is it used?" (3 Marks)
Answer: IsPostBack is a property of the Page class. It returns TRUE if the page is
being loaded in response to a postback (form submission), and FALSE if it is being
loaded for the first time.
Use: Prevents re-initialization of controls on every postback. Always initialize default
values inside if(!IsPostBack){} block.
4.4 [Link] Page Life Cycle
Important topic — pages go through these stages:
Ord Stage Description
er
1 Page Request Page requested by browser — check if cached
2 Start Set IsPostBack, UICulture, Request, Response
properties
3 Initialization Page_Init — controls created, UniqueID set
4 Load Page_Load — restore ViewState/Control state; if
postback, process form data
5 Postback Events Event handlers called (Button_Click etc.)
6 Rendering [Link] — HTML generated from all controls
7 Unload Page_Unload — cleanup, close DB connections
⚠️TRICKY POINT — Page Life Cycle Order
Page_Init fires BEFORE Page_Load — use Page_Init to initialize page-level settings.
Page_Load fires on EVERY request (first load AND postback) — always check
IsPostBack.
Event handlers (Button_Click) fire AFTER Page_Load, not before — common exam
trick question!
Page 11 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
UNIT 5 — Previous Year Questions (PYQs) & Important Questions
📌 FULL LIST — Exam-Focused Questions with Answer Hints
These are the most likely questions based on syllabus analysis:
Short Answer (2 Marks)
Question Key Answer Points
What is [Link]? Microsoft server-side web framework;
runs on .NET CLR; compiled; successor
to Classic ASP
What is a Web Application? Interactive system running on web server
accessed via browser; uses client-server
model; has UI+business logic+data
What is ViewState? [Link] mechanism to persist
page/control state across postbacks;
stored as hidden field in HTML; enabled
by default
What is a Postback? HTTP POST request sent to same page
when user submits a form; IsPostBack =
true on postback
What is IIS? Internet Information Services —
Microsoft's web server that hosts
[Link] applications; handles HTTP
requests
What is Code-Behind? Separation of HTML markup (.aspx) from
C# logic (.[Link]) — improves
maintainability
Difference: .aspx vs .[Link]? .aspx = markup/UI; .[Link] = C# code-
behind logic; both compile to single class
What is runat='server'? Attribute that makes HTML/ASP control
accessible as server-side object with
properties and events
What is [Link]? XML configuration file for [Link] app:
stores DB connections, authentication,
app settings
What is Session in ASP? Server-side storage per user; persists
data across multiple pages/requests;
20min default timeout
Page 12 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Medium Answer (4–5 Marks)
Question Answer Strategy
Explain features of [Link] List 6-8 features from table in Unit 2.
Each feature: name + 1-line description.
Add intro sentence.
Compare ASP vs [Link] 8-10 point comparison table. Mention:
compiled vs interpreted, OOP, code-
behind, web controls, security.
Explain Client-Server Architecture Definition + diagram description +
request-response cycle steps (7 steps) +
mention of IIS and CLR.
Explain components of Web Application List all 6 components (Web Server, App
Server, DB Server, Browser, Middleware,
UI Layer) with roles.
Explain the IDE of Visual Studio Cover: Start Page, Menu, Toolbars,
Solution Explorer, Toolbox, Properties
Window, Design/Code view. 2 lines each.
Steps to create [Link] Web App List 10 steps from Unit 4. Be specific
about dialog boxes and keyboard
shortcuts.
Explain Page Life Cycle List 7 stages in order with brief
description. Mention IsPostBack and
where events fire.
Explain runat='server' attribute It marks controls as server controls;
accessible in code-behind; processed on
server; generates HTML on render.
UNIT 6 — Tricky Points & Common Exam Mistakes
⚠️MASTER LIST — All Tricky Points
Read ALL these points carefully before your exam:
# Tricky Point
1 [Link] is NOT an upgrade of Classic ASP — it's a complete rewrite.
Never say 'upgrade' in exam.
2 Page_Load fires on EVERY page load (first + postback). Use IsPostBack
to distinguish.
3 Event handlers (Button_Click) fire AFTER Page_Load, not
Page 13 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
# Tricky Point
simultaneously.
4 ViewState is stored as a hidden field in the HTML — not on the server
(Session is on server).
5 runat='server' is MANDATORY for any [Link] server control — without
it, the control is treated as plain HTML.
6 IIS is a Web Server — NOT part of [Link] framework. It HOSTS
[Link] applications.
7 CLR (Common Language Runtime) is the execution engine that runs
[Link] compiled code.
8 .[Link] is AUTO-GENERATED — never manually edit this file.
9 [Link] changes take effect IMMEDIATELY — no recompilation
required.
10 Code-Behind file (.[Link]) and .aspx file compile into ONE single partial
class.
11 [Link] handles application-level events (Application_Start,
Session_End) — not page-level.
12 [Link] Web Forms is event-driven; [Link] MVC is request-routing
based — different architectures.
13 Design View in VS is NOT a browser — it uses an internal rendering
engine; always test in real browser.
14 Ctrl+Shift+N = New Project; Ctrl+F5 = Run without debugging; F5 = Run
with debugging.
15 The <form runat='server'> tag is REQUIRED in [Link] Web Forms —
there can only be ONE server-side form per page.
UNIT 7 — Quick Revision Sheet (Last-Minute Notes)
Key Acronyms & Full Forms
Acronym Full Form / Meaning
ASP Active Server Pages
[Link] Active Server Pages .NET (not an
acronym for .NET itself)
IIS Internet Information Services
Page 14 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Acronym Full Form / Meaning
CLR Common Language Runtime
MSIL Microsoft Intermediate Language
(compiled output before JIT)
JIT Just-In-Time Compiler (compiles MSIL to
native code at runtime)
IDE Integrated Development Environment
[Link] ActiveX Data Objects .NET (database
access layer)
MVC Model-View-Controller ([Link]
architectural pattern)
WYSIWYG What You See Is What You Get (Design
View editor)
HTTP HyperText Transfer Protocol
HTML HyperText Markup Language
VS Visual Studio
OOP Object-Oriented Programming
URL Uniform Resource Locator
Important Keyboard Shortcuts — Visual Studio
Shortcut Action Use Case
F5 Start with debugging Run and test web application
Ctrl+F5 Start without debugging Run faster, no breakpoints
Ctrl+Shift+N New Project Create new web application
Ctrl+Shift+B / Build Solution Compile entire project
F6
Ctrl+Alt+L Solution Explorer Open project file tree
Ctrl+Alt+X Toolbox Open controls panel
F4 Properties Window View/edit control properties
Page 15 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Shortcut Action Use Case
Ctrl+Space IntelliSense Auto-complete suggestions
Ctrl+Z / Ctrl+Y Undo / Redo Reverse/repeat last action
F9 Toggle Breakpoint Add/remove debugging
breakpoint
Memory Aid — Classic ASP vs [Link]
🧠 MEMORY TRICK
Classic ASP = Old interpreted script with VBScript — think of it as 'spaghetti code in a
text file'
[Link] = Modern compiled framework — think 'clean architecture with C# classes
and events'
The .NET makes ALL the difference: Compiled, OOP, IDE support, Web Controls,
Security, Caching
One-line answer: "[Link] is a compiled, object-oriented, event-driven web
framework by Microsoft, replacing Classic ASP which was interpreted, not OOP, and
lacked structure."
Common 1-Line Definitions — Memorize These
Term 1-Line Definition
[Link] Server-side web framework by Microsoft, runs on .NET
CLR, used to build dynamic web apps.
Web Application Software program running on a web server, accessed via
browser using HTTP.
Webpage Single HTML document displayed in a browser, may be
static or dynamic.
Client-Server Model where client (browser) requests and server
Architecture responds with data/HTML.
Visual Studio Microsoft's IDE for building .NET, [Link], C#
applications with design and code tools.
Solution Explorer Panel in VS showing all project files in a hierarchical tree
structure.
Toolbox Panel in VS containing draggable web/HTML controls for
designing web forms.
Page 16 of 17
Web Technology — [Link] Exam Notes | Wireless PSI Exam Preparation
Term 1-Line Definition
Properties Window Panel showing editable properties (ID, Text, Color) of
selected control/file.
Code-Behind [Link] pattern separating HTML markup (.aspx) from
C# logic (.[Link]).
ViewState Hidden field mechanism in [Link] to maintain control
values across postbacks.
Postback Submission of a web form back to the same page (HTTP
POST to self).
IIS Microsoft web server that hosts and serves [Link] web
applications.
[Link] XML config file controlling [Link] app settings,
connections, and security.
[Link] File handling application-level events like Application_Start,
Session_End.
🎯 FINAL EXAM TIPS
1. Always write a 1-line definition before answering any 'Explain' question.
2. For 'Difference' questions — always use a TABLE format (minimum 5 points).
3. For 'Explain IDE' — mention at least 6 components with 2 lines each.
4. For steps questions (creating web app) — number every step clearly.
5. Mention IsPostBack whenever Page_Load or page events are discussed.
6. Use examples — e.g., for Web Application: Gmail, Amazon, Online Banking.
7. End long answers with a brief conclusion — examiners appreciate it.
8. For code questions — write code EXACTLY as shown; runat='server' is always
required.
— Best of luck for your Wireless PSI Exam! —
Page 17 of 17