Computer Based Activities

Student: Justin Javier | ID: 18979

Task 1: HTTP and Its Roles

HTTP (Hypertext Transfer Protocol) is the foundation of data communication on the World Wide Web. It is an application-layer protocol that enables the transfer of hypermedia documents, primarily HTML files, between web servers and clients (browsers).

Usage of HTTP

HTTP operates on a request-response model where a client sends a request to a server, and the server responds with the requested resource. The protocol uses methods such as GET (retrieve data), POST (submit data), PUT (update data), and DELETE (remove data) to perform different operations. HTTP is stateless, meaning each request is independent and doesn't retain information from previous requests.

Different Roles in HTTP

Client: The client, typically a web browser, initiates HTTP requests to access web resources. It sends requests containing methods, headers, and sometimes body content to communicate what it needs from the server.

Server: The web server receives HTTP requests from clients, processes them, and sends back appropriate responses. It hosts web applications and resources, handling multiple client requests simultaneously while managing security, authentication, and data processing.

Proxy: Proxies act as intermediaries between clients and servers, forwarding requests and responses. They can provide caching, load balancing, security filtering, and anonymity for clients.

Gateway: Gateways translate HTTP requests between different protocols, enabling communication between systems that use different networking protocols or application layers.

Modern web applications have evolved to use HTTPS (HTTP Secure), which encrypts communication using SSL/TLS protocols, ensuring data privacy and integrity. Understanding HTTP's roles is crucial for developing secure, efficient web applications that properly handle client-server communication.

Task 2: Web Application with Master Page

Created a web application using ASP.NET with a Master Page and five web forms. The first three forms are linked with the master page, while the remaining two are individual pages. Navigation controls allow users to navigate between different pages seamlessly.

Master Page Layout
Main master page with navigation menu
Home Page
Home page linked to master page
About Page
About page with master page
Services Page
Services page with navigation

Task 3: Site Map Creation

Created a site map (Web.sitemap) for the web application to define the navigation structure. The site map provides a hierarchical view of all pages and their relationships.

<?xml version="1.0" encoding="utf-8" ?> <siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0"> <siteMapNode url="~/Home.aspx" title="Home" description="Home Page"> <siteMapNode url="~/About.aspx" title="About" description="About Page" /> <siteMapNode url="~/Services.aspx" title="Services" description="Services Page" /> <siteMapNode url="~/Contact.aspx" title="Contact" description="Contact Page" /> <siteMapNode url="~/Gallery.aspx" title="Gallery" description="Gallery Page" /> </siteMapNode> </siteMap>
Site Map Structure
XML sitemap configuration
Navigation Menu
SiteMapDataSource with Menu control

Task 4: Registration and Login System

Implemented a registration and login system allowing users to become members. The home page includes a registration link, and users can log in after registration to access the application.

Registration Form
User registration page with input fields
Login Page
Login form for registered members
Welcome Dashboard
User dashboard after successful login

Task 5: Form Validation

Implemented validation controls for all required fields in the registration and login forms. Used RequiredFieldValidator, RegularExpressionValidator, and CompareValidator to ensure data integrity.

Email Validation
Email format validation error message
Required Field
Required field validation warning
Password Match
Password confirmation validation

Task 6: Debugging Operations

Performed debugging operations for Tasks 2-5 using Visual Studio debugger. Set breakpoints, inspected variables, and used step-through debugging to identify and resolve issues.

Breakpoint Set
Breakpoints in code editor
Watch Window
Variable inspection in debug mode
Call Stack
Call stack during debugging session

Task 7: Error Identification and Fixes

Program A - Fixed Code

Error: Semicolon used instead of comma in method call

protected void Button_Click(object sender, System.EventArgs e) { int number, result; number = System.Convert.ToInt32(NumberTextBox.Text); result = Square(number); // Fixed: Changed ':' to ';' ResultLabel.Text = NumberTextBox.Text + " squared is " + result.ToString(); }

Program B - Fixed Code with Try-Catch

Error: Division by zero exception, missing try-catch block

using System; namespace ErrorHandlingApplication { class DivNumbers { static void Main(string[] args) { try { int num1, num2, result; num1 = 6; num2 = 0; result = num1 / num2; Console.WriteLine("Result: {0}", result); // Fixed: Response to Console } catch (DivideByZeroException ex) { Console.WriteLine("Error: Cannot divide by zero!"); Console.WriteLine("Exception: " + ex.Message); } catch (Exception ex) { Console.WriteLine("An error occurred: " + ex.Message); } } } }
Debug Output
Error caught and displayed properly

Task 8: Simple Database Application

Created a database application with CRUD operations. The application demonstrates connection to SQL Server, data retrieval, insertion, updating, and deletion with proper error handling.

using System; using System.Data.SqlClient; protected void LoadData() { try { string connectionString = "Data Source=.;Initial Catalog=StudentDB;Integrated Security=True"; using (SqlConnection conn = new SqlConnection(connectionString)) { conn.Open(); string query = "SELECT * FROM Students"; SqlCommand cmd = new SqlCommand(query, conn); SqlDataReader reader = cmd.ExecuteReader(); GridView1.DataSource = reader; GridView1.DataBind(); } } catch (Exception ex) { Response.Write("Error: " + ex.Message); } }
Database Connection
Application connected to database
Breakpoint Active
Debug mode with breakpoints
Data Grid View
Student records displayed in GridView

Task 9: Log4net Components and Logger Functionality

Main Components of Log4net

Log4net is a powerful logging framework for .NET applications with three main components:

1. Loggers: Loggers are the entry points for logging messages. They are hierarchically organized and named, typically following the namespace structure of the application. Loggers determine whether a log message should be processed based on configured logging levels (DEBUG, INFO, WARN, ERROR, FATAL).

2. Appenders: Appenders define where log messages are sent. Common appenders include FileAppender (writes to files), ConsoleAppender (outputs to console), DatabaseAppender (stores in databases), and EmailAppender (sends via email). Multiple appenders can be configured simultaneously to send logs to different destinations.

3. Layouts: Layouts format log messages before they're written by appenders. The PatternLayout is most commonly used, allowing custom formatting with placeholders for timestamp, log level, logger name, message, and exception details.

How Loggers Work in Log4net

Loggers function through a hierarchical system where child loggers inherit configurations from parent loggers unless explicitly overridden. When an application calls a logging method, the logger checks if the message's severity level meets the configured threshold. If it does, the message passes through configured filters and is formatted by the layout before being sent to all attached appenders. This architecture provides flexible, centralized logging control while maintaining minimal performance impact on the application. Developers can dynamically adjust logging behavior through configuration files without code changes, making it invaluable for debugging and monitoring production applications.

Feedback & Survey