Advanced .NET Technology

Difference between ASP.NET and .NET Core

.NET architecture

The .NET Framework has these main parts:

1. Operating system and hardware at the bottom, on which the framework runs.
2. CLR (Common Language Runtime) is the execution engine. It provides memory management and garbage collection, the Common Type System (CTS), exception handling, thread management, code access security and JIT (Just-In-Time) compilation.
3. Base Class Library (BCL / FCL) is the set of reusable classes, such as System, System.IO, System.Collections and System.Data.
4. Application models are ASP.NET (web), Windows Forms/WPF (desktop), ADO.NET (data), WCF and others.
5. Languages such as C#, VB.NET and F# follow the Common Language Specification (CLS), so they can interoperate.

Execution flow: source code (C#, VB.NET) is compiled by the language compiler into MSIL (Intermediate Language) plus metadata inside an assembly (.exe/.dll). At run time the CLR's JIT compiler converts the MSIL into native machine code, which then runs under CLR control (verification, garbage collection, security).

Two usages of an interface

1. Defining a contract (abstraction): an interface declares members (methods, properties, events) without implementation. Every implementing class must provide them, so unrelated classes can be used through a common type (polymorphism, loose coupling).
2. Achieving multiple inheritance: C# does not allow a class to inherit from more than one class, but a class can implement any number of interfaces.

Program: multiple inheritance using interfaces

using System;

interface IShape
{
    double Area();
}

interface IPrintable
{
    void Print();
}

class Rectangle : IShape, IPrintable
{
    double l, b;
    public Rectangle(double l, double b) { this.l = l; this.b = b; }

    public double Area() { return l * b; }

    public void Print()
    {
        Console.WriteLine("Rectangle {0} x {1}, Area = {2}", l, b, Area());
    }
}

class Program
{
    static void Main()
    {
        Rectangle r = new Rectangle(5, 4);
        r.Print();

        IShape s = r;          // use through the first interface
        Console.WriteLine("Area via IShape = " + s.Area());
        IPrintable p = r;      // use through the second interface
        p.Print();
    }
}

Class Rectangle inherits behaviour from both IShape and IPrintable, which achieves multiple inheritance.

throw vs throws

C# has only the throw keyword. throws belongs to Java.

Program: copy a file using BinaryReader and BinaryWriter

using System;
using System.IO;

class FileCopy
{
    static void Main()
    {
        try
        {
            using (BinaryReader br = new BinaryReader(File.Open("source.dat", FileMode.Open)))
            using (BinaryWriter bw = new BinaryWriter(File.Open("dest.dat", FileMode.Create)))
            {
                byte[] buffer = new byte[1024];
                int n;
                while ((n = br.Read(buffer, 0, buffer.Length)) > 0)
                {
                    bw.Write(buffer, 0, n);
                }
            }
            Console.WriteLine("File copied successfully.");
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Source file not found.");
        }
        catch (IOException e)
        {
            Console.WriteLine("IO error: " + e.Message);
        }
    }
}

Benefits of Windows Forms

• Rapid application development (RAD) with the drag-and-drop designer in Visual Studio.
• A rich set of ready-made controls (Button, TextBox, DataGridView, etc.).
• Event-driven programming model that is easy to learn.
• Easy data binding to databases through ADO.NET.
• Rich, responsive native UI with access to local resources (files, printers).
• Controls can be inherited and customised (user controls). Forms support inheritance and reuse.
• Strong .NET class library support and easy deployment (ClickOnce).

Common properties and events of controls

Properties common to almost all controls are Name, Text, Enabled, Visible, Location, Size, Font, BackColor and ForeColor.

Tooltip

A tooltip is a small pop-up text box that appears when the mouse pointer rests over a control. It gives a short hint about the control. In Windows Forms the ToolTip component is used: toolTip1.SetToolTip(button1, "Click to save");

Types of dialog box

A dialog box is a window used to interact with the user to get input or show information. There are two types.

1. Modal dialog box: the user must close it before returning to the parent form. It is shown with ShowDialog(). Examples are the common dialogs (OpenFileDialog, SaveFileDialog, ColorDialog, FontDialog) and MessageBox.
2. Modeless dialog box: the user can switch between the dialog and the parent form without closing it. It is shown with Show(). An example is a Find and Replace window.

Examples

// Modal: message box and file dialog
private void btnOpen_Click(object sender, EventArgs e)
{
    OpenFileDialog ofd = new OpenFileDialog();
    ofd.Filter = "Text files|*.txt";
    if (ofd.ShowDialog() == DialogResult.OK)
    {
        textBox1.Text = System.IO.File.ReadAllText(ofd.FileName);
    }
}

private void btnExit_Click(object sender, EventArgs e)
{
    DialogResult r = MessageBox.Show("Do you want to exit?", "Confirm",
                       MessageBoxButtons.YesNo, MessageBoxIcon.Question);
    if (r == DialogResult.Yes) Application.Exit();
}

// Modeless: custom form
private void btnFind_Click(object sender, EventArgs e)
{
    FindForm f = new FindForm();
    f.Show();          // user can still use the main form
}

// Modal custom form
private void btnLogin_Click(object sender, EventArgs e)
{
    LoginForm f = new LoginForm();
    f.ShowDialog();    // main form blocked until closed
}

ADO.NET

ADO.NET (ActiveX Data Objects .NET) is the .NET data access technology for connecting to a data source, executing commands and retrieving, manipulating and updating data. Its main classes are Connection, Command, DataReader, DataAdapter, DataSet and DataTable. It supports connected and disconnected data access.

DataSet vs DataReader

Example

string cs = "Data Source=.;Initial Catalog=College;Integrated Security=True";

// DataReader
using (SqlConnection con = new SqlConnection(cs))
{
    SqlCommand cmd = new SqlCommand("select * from Student", con);
    con.Open();
    SqlDataReader dr = cmd.ExecuteReader();
    while (dr.Read())
        Console.WriteLine(dr["Name"]);
}

// DataSet
using (SqlConnection con = new SqlConnection(cs))
{
    SqlDataAdapter da = new SqlDataAdapter("select * from Student", con);
    DataSet ds = new DataSet();
    da.Fill(ds, "Student");          // connection opened and closed automatically
    foreach (DataRow row in ds.Tables["Student"].Rows)
        Console.WriteLine(row["Name"]);
}

GDI+

GDI+ (Graphics Device Interface Plus) is the .NET graphics API in the System.Drawing namespace. It is used to draw 2D graphics, text and images on the screen or printer through a Graphics object, using Pen, Brush, Font and Color. It can draw lines, rectangles, ellipses, curves, polygons and images.

Program: draw a line and a circle in a Windows Form

using System;
using System.Drawing;
using System.Windows.Forms;

public class DrawForm : Form
{
    public DrawForm()
    {
        this.Text = "GDI+ Demo";
        this.Size = new Size(400, 350);
        this.Paint += new PaintEventHandler(DrawForm_Paint);
    }

    private void DrawForm_Paint(object sender, PaintEventArgs e)
    {
        Graphics g = e.Graphics;
        Pen pen = new Pen(Color.Blue, 3);

        // line from (30,50) to (300,50)
        g.DrawLine(pen, 30, 50, 300, 50);

        // circle: ellipse with equal width and height (diameter 100)
        g.DrawEllipse(Pens.Red, 100, 100, 100, 100);

        // filled circle
        g.FillEllipse(Brushes.Green, 100, 220, 80, 80);

        pen.Dispose();
    }

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.Run(new DrawForm());
    }
}

DrawEllipse with equal width and height produces a circle.

(a) Two architectures of ADO.NET

1. Connected architecture

The application keeps an open connection to the database while it works. It uses SqlConnection, SqlCommand and SqlDataReader.

• The data reader is forward-only and read-only.
• It is fast and uses little memory.
• It needs a continuous connection, so it is not scalable for many users.
• It is suitable for reading large amounts of data once.

2. Disconnected architecture

Data is fetched using a SqlDataAdapter, stored in a DataSet/DataTable in memory, and the connection is closed. The user works on the in-memory copy and the changes are sent back with adapter.Update().

• It is scalable, since the connection is held briefly.
• It supports multiple tables, relations, sorting and filtering, and the data can be serialised to XML.
• It uses more memory and the data may be stale or cause concurrency conflicts.

(b) Transaction using ADO.NET

using System;
using System.Data.SqlClient;

class TransactionDemo
{
    static void Main()
    {
        string cs = "Data Source=.;Initial Catalog=Bank;Integrated Security=True";
        using (SqlConnection con = new SqlConnection(cs))
        {
            con.Open();
            SqlTransaction tran = con.BeginTransaction();
            try
            {
                SqlCommand c1 = new SqlCommand(
                  "update Account set Balance = Balance - 500 where AccNo = 1", con, tran);
                c1.ExecuteNonQuery();

                SqlCommand c2 = new SqlCommand(
                  "update Account set Balance = Balance + 500 where AccNo = 2", con, tran);
                c2.ExecuteNonQuery();

                tran.Commit();                 // both succeed
                Console.WriteLine("Transaction committed.");
            }
            catch (Exception ex)
            {
                tran.Rollback();               // undo everything on failure
                Console.WriteLine("Rolled back: " + ex.Message);
            }
        }
    }
}

Either both updates are applied (commit) or none (rollback), which preserves atomicity.

(a) Docker and containerization

Containerization packages an application with all its dependencies (runtime, libraries, configuration) into a lightweight, isolated unit called a container. Containers share the host OS kernel, so they start in seconds and use fewer resources than virtual machines. They run the same way on a developer's laptop, a test server and the cloud.

Docker is the most popular containerization platform. Its key concepts:

• Dockerfile: a text file with instructions to build an image.
• Image: a read-only template containing the app and its dependencies.
• Container: a running instance of an image.
• Docker Hub / registry: a place to store and share images.
• Docker Engine: the daemon that builds and runs containers.

Example: containerizing an ASP.NET Core app

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /out

FROM base AS final
WORKDIR /app
COPY --from=build /out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

docker build -t myapp .
docker run -d -p 8080:80 myapp

(b) Windows Forms CRUD for Employee

Assume the table Employee(Id int primary key, Name varchar(50), Address varchar(50), Salary decimal). The form has TextBoxes txtId, txtName, txtAddress, txtSalary, buttons btnInsert, btnUpdate, btnDelete, btnView and a DataGridView dgv.

using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms;

public partial class EmployeeForm : Form
{
    string cs = "Data Source=.;Initial Catalog=Company;Integrated Security=True";

    public EmployeeForm() { InitializeComponent(); }

    private void Load_Data()
    {
        using (SqlConnection con = new SqlConnection(cs))
        {
            SqlDataAdapter da = new SqlDataAdapter("select * from Employee", con);
            DataTable dt = new DataTable();
            da.Fill(dt);
            dgv.DataSource = dt;
        }
    }

    private void Execute(string sql)
    {
        using (SqlConnection con = new SqlConnection(cs))
        {
            SqlCommand cmd = new SqlCommand(sql, con);
            cmd.Parameters.AddWithValue("@id", int.Parse(txtId.Text));
            cmd.Parameters.AddWithValue("@name", txtName.Text);
            cmd.Parameters.AddWithValue("@addr", txtAddress.Text);
            cmd.Parameters.AddWithValue("@sal", decimal.Parse(txtSalary.Text));
            con.Open();
            cmd.ExecuteNonQuery();
        }
        Load_Data();
    }

    private void btnInsert_Click(object s, EventArgs e) =>
        Execute("insert into Employee values(@id,@name,@addr,@sal)");

    private void btnUpdate_Click(object s, EventArgs e) =>
        Execute("update Employee set Name=@name, Address=@addr, Salary=@sal where Id=@id");

    private void btnDelete_Click(object s, EventArgs e) =>
        Execute("delete from Employee where Id=@id");

    private void btnView_Click(object s, EventArgs e) => Load_Data();

    private void dgv_CellClick(object s, DataGridViewCellEventArgs e)
    {
        if (e.RowIndex < 0) return;
        DataGridViewRow r = dgv.Rows[e.RowIndex];
        txtId.Text = r.Cells[0].Value.ToString();
        txtName.Text = r.Cells[1].Value.ToString();
        txtAddress.Text = r.Cells[2].Value.ToString();
        txtSalary.Text = r.Cells[3].Value.ToString();
    }
}

Create is the insert, Read is the view, Update is the update and Delete is the delete.

(a) Multithreading with Sleep()

using System;
using System.Threading;

class ThreadDemo
{
    static void PrintNumbers()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine("Numbers thread: " + i);
            Thread.Sleep(500);          // pause for 500 ms
        }
    }

    static void PrintLetters()
    {
        for (char c = 'A'; c <= 'E'; c++)
        {
            Console.WriteLine("Letters thread: " + c);
            Thread.Sleep(700);
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(PrintNumbers);
        Thread t2 = new Thread(PrintLetters);
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("Main thread finished.");
    }
}

The two threads run concurrently, and Sleep() suspends the current thread for the given milliseconds so the output interleaves.

(b) Factorial in a Windows Form

Assumed form layout: txtNumber (TextBox), btnCalculate (Button) and lblResult (Label).

using System;
using System.Windows.Forms;

public partial class FactorialForm : Form
{
    public FactorialForm() { InitializeComponent(); }

    private void btnCalculate_Click(object sender, EventArgs e)
    {
        int n;
        if (!int.TryParse(txtNumber.Text, out n) || n < 0)
        {
            MessageBox.Show("Enter a non-negative integer.");
            return;
        }
        long fact = 1;
        for (int i = 2; i <= n; i++)
            fact *= i;
        lblResult.Text = "Factorial of " + n + " = " + fact;
    }
}

For example, entering 5 shows Factorial of 5 = 120. A long holds values only up to 20!.

Thread lifecycle

A thread in .NET (System.Threading.Thread) passes through these states (ThreadState):

1. Unstarted: the thread object has been created (new Thread(...)) but Start() has not been called.
2. Runnable / Running: after Start() the thread is ready and is scheduled by the OS to run on the CPU.
3. Waiting / Blocked (WaitSleepJoin): the thread is paused by Sleep(), Join(), Wait() or a lock/IO wait. It returns to runnable when the condition ends.
4. Suspended / Aborted-requested: the thread has been asked to stop (Abort, now deprecated) or cancelled.
5. Stopped (Dead): the thread has finished its method or been terminated. It cannot be restarted.

Unstarted --Start()--> Running <--> WaitSleepJoin
                          |
                      (finish / Abort)
                          v
                       Stopped

Multithreaded program

using System;
using System.Threading;

class Program
{
    static void Worker(string name)
    {
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine(name + " : step " + i);
            Thread.Sleep(300);
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(() => Worker("Thread-1"));
        Thread t2 = new Thread(() => Worker("Thread-2"));
        Console.WriteLine("t1 state: " + t1.ThreadState);   // Unstarted
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine("t1 state: " + t1.ThreadState);   // Stopped
    }
}

MDI form

A Multiple Document Interface (MDI) application has one parent window that can host several child windows inside it (for example Word with several documents, or a text editor with several files). Set the parent's IsMdiContainer = true and set each child's MdiParent:

Form2 child = new Form2();
child.MdiParent = this;
child.Show();
this.LayoutMdi(MdiLayout.Cascade);   // also TileHorizontal, TileVertical, ArrangeIcons

Types of dialog boxes

1. Modal dialog box: the user must close it before returning to the owner form. It is shown with ShowDialog(). Examples are MessageBox, OpenFileDialog, SaveFileDialog, ColorDialog, FontDialog and a custom login form.
2. Modeless dialog box: the owner form stays accessible while the dialog is open. It is shown with Show(). An example is a Find/Replace box.

// Modal
ColorDialog cd = new ColorDialog();
if (cd.ShowDialog() == DialogResult.OK)
    this.BackColor = cd.Color;

MessageBox.Show("Saved successfully", "Info",
    MessageBoxButtons.OK, MessageBoxIcon.Information);

// Modeless
FindDialog f = new FindDialog();
f.Owner = this;
f.Show();

DialogResult (OK, Cancel, Yes, No) returns which button the user pressed.

Connected vs disconnected ADO.NET architecture

Example: connected

SqlConnection con = new SqlConnection(cs);
SqlCommand cmd = new SqlCommand("select Name from Student", con);
con.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
    Console.WriteLine(dr[0]);
con.Close();

Example: disconnected

SqlDataAdapter da = new SqlDataAdapter("select * from Student", cs);
SqlCommandBuilder cb = new SqlCommandBuilder(da);
DataSet ds = new DataSet();
da.Fill(ds, "Student");                 // connection closed after filling

ds.Tables["Student"].Rows[0]["Name"] = "Hari";   // edit in memory
da.Update(ds, "Student");               // push changes to the database

Virtual directory in IIS

A virtual directory is a name (alias) in IIS that maps to a physical folder on disk, which may be anywhere on the server or on another computer. For example, the URL http://localhost/MyApp can point to D:\Projects\MyApp. It lets a site publish content from outside its root folder and hides the real file path from users. It is created in IIS Manager with right-click on the site, then Add Virtual Directory, giving an alias and a physical path.

ASP.NET web form: create and access a session

Default.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<html>
<body>
  <form id="form1" runat="server">
    Name: <asp:TextBox ID="txtName" runat="server" />
    <asp:Button ID="btnCreate" runat="server" Text="Create Session" OnClick="btnCreate_Click" />
    <asp:Button ID="btnAccess" runat="server" Text="Access Session" OnClick="btnAccess_Click" />
    <br />
    <asp:Label ID="lblMsg" runat="server" />
  </form>
</body>
</html>

Default.aspx.cs

using System;

public partial class _Default : System.Web.UI.Page
{
    protected void btnCreate_Click(object sender, EventArgs e)
    {
        Session["UserName"] = txtName.Text;     // create session variable
        Session.Timeout = 20;                   // minutes
        lblMsg.Text = "Session created.";
    }

    protected void btnAccess_Click(object sender, EventArgs e)
    {
        if (Session["UserName"] != null)
            lblMsg.Text = "Hello, " + Session["UserName"].ToString();
        else
            lblMsg.Text = "No session found.";
    }
}

MVC in ASP.NET Core

MVC (Model-View-Controller) separates an application into three parts:

• Model: the data and business logic (classes, validation, database access).
• View: the UI, written in Razor (.cshtml), which displays model data.
• Controller: it handles the HTTP request, works with the model and returns a view.

Request flow: URL, then routing, then the controller action, then the model, then the view, then the HTML response to the browser.

Benefits are separation of concerns, easy unit testing, parallel development and clean URLs.

Example

Model Models/Student.cs

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Controller Controllers/StudentController.cs

using Microsoft.AspNetCore.Mvc;

public class StudentController : Controller
{
    public IActionResult Index()
    {
        var student = new Student { Id = 1, Name = "Sita" };
        return View(student);          // passes the model to Views/Student/Index.cshtml
    }
}

View Views/Student/Index.cshtml

@model Student
<h2>Student Details</h2>
<p>Id: @Model.Id</p>
<p>Name: @Model.Name</p>

Routing in Program.cs:

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

Visiting /Student/Index runs the action and renders the view.

AJAX

AJAX (Asynchronous JavaScript and XML) is a technique for sending requests to the server and updating part of a web page in the background without reloading the whole page. It gives faster, smoother, more interactive pages. It uses JavaScript, XMLHttpRequest/fetch, the DOM and XML/JSON.

ASP.NET AJAX server controls

• ScriptManager: manages the AJAX client scripts. One is required on each page that uses AJAX.
• UpdatePanel: defines the region of the page that is refreshed partially (asynchronous postback). It has ContentTemplate and Triggers.
• UpdateProgress: shows a status message (e.g. "Loading...") while an UpdatePanel is updating.
• Timer: triggers postbacks at fixed intervals.
• ScriptManagerProxy: used in content or user control pages when a master page already holds a ScriptManager.

Example

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

<asp:UpdatePanel ID="UpdatePanel1" runat="server">
  <ContentTemplate>
    <asp:Label ID="lblTime" runat="server" />
    <asp:Button ID="btnTime" runat="server" Text="Show Time" OnClick="btnTime_Click" />
  </ContentTemplate>
</asp:UpdatePanel>

<asp:UpdateProgress ID="UpdateProgress1" runat="server">
  <ProgressTemplate>Please wait...</ProgressTemplate>
</asp:UpdateProgress>

protected void btnTime_Click(object sender, EventArgs e)
{
    System.Threading.Thread.Sleep(1000);
    lblTime.Text = DateTime.Now.ToString();
}

Only the label and button update, and the rest of the page does not reload.

Hosting models

A hosting model describes how an ASP.NET Core application runs on a server.

1. In-process hosting: the app runs inside the IIS worker process (w3wp.exe) using the IIS HTTP Server. It has better performance and is the default for IIS.
2. Out-of-process hosting: the app runs as a separate process on the Kestrel web server. IIS, Nginx or Apache act as a reverse proxy and forward requests to Kestrel. It is used on Linux and when running Kestrel directly.
3. Self-hosting / containers: Kestrel runs as a console app, in a Windows Service or in a Docker container, and cloud hosting (Azure, AWS) is also possible.

Docker and containerization

Containerization packages an application with its runtime, libraries and configuration into an isolated container. Containers share the host OS kernel, so they are lighter and faster than virtual machines. The result is the same behaviour in development, testing and production.

Docker is the platform to build, ship and run containers.

• Dockerfile gives the build instructions.
• Image is a read-only template built from a Dockerfile.
• Container is a running instance of an image.
• Registry (Docker Hub) stores images.
• Docker Engine is the daemon that runs containers.

Advantages: portability, isolation, consistency across environments, fast start-up, efficient resource use, easy scaling and CI/CD integration.

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /out

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /out .
EXPOSE 80
ENTRYPOINT ["dotnet", "WebApp.dll"]

docker build -t webapp .
docker run -d -p 8080:80 webapp

Assume the table:

CREATE TABLE Employee(
    EmpId int PRIMARY KEY,
    Name varchar(50),
    Address varchar(50),
    Gender varchar(10),
    Department varchar(30)
);

EmployeeForm.aspx

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="EmployeeForm.aspx.cs" Inherits="EmployeeForm" %>
<html>
<body>
<form id="form1" runat="server">
  <table>
    <tr><td>Employee Id</td><td><asp:TextBox ID="txtId" runat="server" /></td></tr>
    <tr><td>Name</td><td><asp:TextBox ID="txtName" runat="server" /></td></tr>
    <tr><td>Address</td><td><asp:TextBox ID="txtAddress" runat="server" /></td></tr>
    <tr><td>Gender</td><td>
      <asp:RadioButtonList ID="rblGender" runat="server" RepeatDirection="Horizontal">
        <asp:ListItem>Male</asp:ListItem>
        <asp:ListItem>Female</asp:ListItem>
      </asp:RadioButtonList></td></tr>
    <tr><td>Department</td><td>
      <asp:DropDownList ID="ddlDept" runat="server">
        <asp:ListItem>IT</asp:ListItem>
        <asp:ListItem>HR</asp:ListItem>
        <asp:ListItem>Finance</asp:ListItem>
      </asp:DropDownList></td></tr>
  </table>
  <asp:Button ID="btnInsert" runat="server" Text="Insert" OnClick="btnInsert_Click" />
  <asp:Button ID="btnSelect" runat="server" Text="Select" OnClick="btnSelect_Click" />
  <br /><asp:Label ID="lblMsg" runat="server" />
  <asp:GridView ID="gvEmployee" runat="server" />
</form>
</body>
</html>

EmployeeForm.aspx.cs

using System;
using System.Data;
using System.Data.SqlClient;

public partial class EmployeeForm : System.Web.UI.Page
{
    string cs = "Data Source=.;Initial Catalog=Company;Integrated Security=True";

    protected void btnInsert_Click(object sender, EventArgs e)
    {
        using (SqlConnection con = new SqlConnection(cs))
        {
            SqlCommand cmd = new SqlCommand(
              "insert into Employee values(@id,@name,@addr,@gender,@dept)", con);
            cmd.Parameters.AddWithValue("@id", int.Parse(txtId.Text));
            cmd.Parameters.AddWithValue("@name", txtName.Text);
            cmd.Parameters.AddWithValue("@addr", txtAddress.Text);
            cmd.Parameters.AddWithValue("@gender", rblGender.SelectedValue);
            cmd.Parameters.AddWithValue("@dept", ddlDept.SelectedValue);
            con.Open();
            cmd.ExecuteNonQuery();
            lblMsg.Text = "Employee inserted successfully.";
        }
    }

    protected void btnSelect_Click(object sender, EventArgs e)
    {
        using (SqlConnection con = new SqlConnection(cs))
        {
            SqlDataAdapter da = new SqlDataAdapter(
              "select * from Employee where Address=@addr and Department=@dept", con);
            da.SelectCommand.Parameters.AddWithValue("@addr", "Ktm");
            da.SelectCommand.Parameters.AddWithValue("@dept", "IT");
            DataTable dt = new DataTable();
            da.Fill(dt);
            gvEmployee.DataSource = dt;
            gvEmployee.DataBind();
        }
    }
}

The Select button runs a parameterised query for address Ktm and department IT and binds the result to the grid. The classic DataGrid and GridView bind in the same way.

(a) Typed dataset

A typed DataSet is a class generated (in Visual Studio, by adding a DataSet .xsd item) that derives from DataSet and exposes tables, rows and columns as strongly typed properties. It gives compile-time checking and IntelliSense. For example, ds.Student[0].Name is used in place of ds.Tables["Student"].Rows[0]["Name"].

Assume a typed dataset StudentDS with the table Student (Id, Name, Address), generated from the database.

using System;

class TypedDataSetDemo
{
    static void Main()
    {
        StudentDS ds = new StudentDS();

        // add rows using strongly typed methods
        ds.Student.AddStudentRow(1, "Ram", "Kathmandu");
        ds.Student.AddStudentRow(2, "Sita", "Pokhara");

        // read with typed properties (no casting, no string column names)
        foreach (StudentDS.StudentRow row in ds.Student)
        {
            Console.WriteLine("{0} {1} {2}", row.Id, row.Name, row.Address);
        }

        // find and edit
        StudentDS.StudentRow r = ds.Student.FindById(2);
        r.Address = "Lalitpur";
        Console.WriteLine(ds.Student[1].Address);
    }
}

(b) Copy a file using BinaryReader and BinaryWriter

using System;
using System.IO;

class CopyFile
{
    static void Main()
    {
        using (BinaryReader br = new BinaryReader(new FileStream("a.dat", FileMode.Open)))
        using (BinaryWriter bw = new BinaryWriter(new FileStream("b.dat", FileMode.Create)))
        {
            byte[] buf = new byte[4096];
            int n;
            while ((n = br.Read(buf, 0, buf.Length)) > 0)
                bw.Write(buf, 0, n);
        }
        Console.WriteLine("Copied.");
    }
}

ASP.NET vs ASP.NET Core

Simple interest application (Razor Page, model and controller)

Model Models/InterestModel.cs

using System.ComponentModel.DataAnnotations;

public class InterestModel
{
    [Required] public double Principal { get; set; }
    [Required] public double Rate { get; set; }
    [Required] public double Time { get; set; }
    public double? SimpleInterest { get; set; }
}

Controller Controllers/InterestController.cs

using Microsoft.AspNetCore.Mvc;

public class InterestController : Controller
{
    [HttpGet]
    public IActionResult Index() => View(new InterestModel());

    [HttpPost]
    public IActionResult Index(InterestModel m)
    {
        if (ModelState.IsValid)
            m.SimpleInterest = (m.Principal * m.Rate * m.Time) / 100;
        return View(m);
    }
}

Razor view Views/Interest/Index.cshtml

@model InterestModel
<h2>Simple Interest Calculator</h2>
<form asp-action="Index" method="post">
    <div>Principal (Rs): <input asp-for="Principal" /></div>
    <div>Rate (%): <input asp-for="Rate" /></div>
    <div>Time (years): <input asp-for="Time" /></div>
    <button type="submit">Calculate</button>
</form>

@if (Model.SimpleInterest != null)
{
    <p>Simple Interest = Rs @Model.SimpleInterest</p>
}

The calculation uses

$SI = \frac{P \times R \times T}{100}$

For example, $P = 10000$, $R = 5$, $T = 2$ gives $SI = \frac{10000 \times 5 \times 2}{100} = 1000$, so the interest is Rs 1000.

Program.cs needs builder.Services.AddControllersWithViews(); and app.MapControllerRoute(name: "default", pattern: "{controller=Interest}/{action=Index}/{id?}");.

Thread

A thread is the smallest unit of execution within a process. A process can have many threads that share its memory and resources but run independently. Multithreading allows several tasks to run concurrently, improving responsiveness and CPU use. In C# threads are created with System.Threading.Thread.

Program: multiple threads along with the main thread

using System;
using System.Threading;

class Program
{
    static void Task1()
    {
        for (int i = 1; i <= 4; i++)
        {
            Console.WriteLine("Thread 1: " + i);
            Thread.Sleep(400);
        }
    }

    static void Task2()
    {
        for (int i = 1; i <= 4; i++)
        {
            Console.WriteLine("Thread 2: " + i);
            Thread.Sleep(600);
        }
    }

    static void Main()
    {
        Thread.CurrentThread.Name = "Main";
        Thread t1 = new Thread(new ThreadStart(Task1));
        Thread t2 = new Thread(new ThreadStart(Task2));
        t1.Start();
        t2.Start();

        for (int i = 1; i <= 4; i++)
        {
            Console.WriteLine(Thread.CurrentThread.Name + " thread: " + i);
            Thread.Sleep(500);
        }

        t1.Join();
        t2.Join();
        Console.WriteLine("All threads completed.");
    }
}

The main thread and the two worker threads run concurrently, so their output is interleaved.

SDI vs MDI

Form inheritance in Windows applications

Visual (form) inheritance lets a new form derive from an existing form and inherit its controls, properties and code. This promotes reuse (for example a common base form with logo, header and Save/Cancel buttons).

Steps:

1. Create the base form BaseForm, build the project, and set controls the children may change to Protected or Public (Modifiers property).
2. Add a new item, Inherited Form, and choose BaseForm as the base, or write the class manually:

public class BaseForm : Form
{
    protected Button btnClose = new Button();
    public BaseForm() { btnClose.Text = "Close"; btnClose.Click += (s, e) => Close(); Controls.Add(btnClose); }
}

public class StudentForm : BaseForm      // inherits controls and behaviour
{
    public StudentForm() { Text = "Student"; }
}

The derived form shows all base controls and can add new ones or override behaviour.

Disconnected architecture in ADO.NET

In the disconnected architecture the application connects to the database only to fetch or save data. A DataAdapter fills a DataSet/DataTable, the connection closes, and the application works on the in-memory copy. Changes are later sent back with DataAdapter.Update().

SqlDataAdapter da = new SqlDataAdapter("select * from Student", cs);
SqlCommandBuilder cb = new SqlCommandBuilder(da);
DataSet ds = new DataSet();
da.Fill(ds, "Student");
ds.Tables["Student"].Rows[0]["Name"] = "Gita";
da.Update(ds, "Student");

Advantages are scalability, fewer connections, support for multiple tables and relations, and XML support. Disadvantages are higher memory use and possible stale data or update conflicts.

ADO.NET vs classic ADO

HTML server controls vs Web server controls

Example

<!-- HTML server control -->
<input type="text" id="txtHtml" runat="server" />
<input type="button" id="btnHtml" value="HTML Button" runat="server" onserverclick="btnHtml_Click" />

<!-- Web server control -->
<asp:TextBox ID="txtWeb" runat="server" />
<asp:Button ID="btnWeb" runat="server" Text="Web Button" OnClick="btnWeb_Click" />

protected void btnHtml_Click(object sender, EventArgs e) { txtHtml.Value = "Hello HTML"; }
protected void btnWeb_Click(object sender, EventArgs e)  { txtWeb.Text  = "Hello Web"; }

An HTML control uses .Value while a web control uses .Text.

Authentication

Authentication is the process of verifying the identity of a user, normally by credentials such as a user name and password. It answers "who are you?" and is different from authorization, which decides what the user may access. ASP.NET supports Windows, Forms and Passport/Token authentication.

Forms authentication

Forms authentication lets the application show its own login page and keep the user's identity in an encrypted cookie (authentication ticket).

Working:

1. The user requests a protected page.
2. ASP.NET sees no valid ticket and redirects to the login page.
3. The user submits credentials and the app validates them (for example against a database).
4. On success, FormsAuthentication.RedirectFromLoginPage(userName, persist) issues the cookie and sends the user to the originally requested page.
5. Later requests carry the cookie, so no new login is needed.
6. FormsAuthentication.SignOut() removes the cookie.

web.config

<system.web>
  <authentication mode="Forms">
    <forms loginUrl="Login.aspx" timeout="30" />
  </authentication>
  <authorization>
    <deny users="?" />   <!-- deny anonymous users -->
  </authorization>
</system.web>

Login.aspx.cs

protected void btnLogin_Click(object sender, EventArgs e)
{
    if (txtUser.Text == "admin" && txtPass.Text == "1234")   // normally checked in the database
        FormsAuthentication.RedirectFromLoginPage(txtUser.Text, false);
    else
        lblMsg.Text = "Invalid username or password";
}

Controls of ASP.NET AJAX

ASP.NET AJAX provides server controls that add asynchronous behaviour without writing JavaScript.

1. ScriptManager: the core control. It manages the AJAX scripts, enables partial-page rendering and must appear once on a page before other AJAX controls.
2. UpdatePanel: marks a region that is refreshed through asynchronous postbacks, so only that region changes. ContentTemplate holds the controls, and Triggers (AsyncPostBackTrigger, PostBackTrigger) define what causes the update. UpdateMode can be Always or Conditional.
3. UpdateProgress: shows a progress message or animation while an UpdatePanel is being updated (AssociatedUpdatePanelID, ProgressTemplate, DisplayAfter).
4. Timer: raises postbacks at a set interval (Interval in ms, Tick event). It is used for auto-refresh, for example a clock or news ticker.
5. ScriptManagerProxy: lets content pages or user controls register scripts or services when the ScriptManager is already on the master page.
6. AJAX Control Toolkit controls: extenders such as AutoCompleteExtender, CalendarExtender, ModalPopupExtender, Accordion, TabContainer and ConfirmButtonExtender.

<asp:ScriptManager ID="sm" runat="server" />
<asp:Timer ID="Timer1" runat="server" Interval="1000" OnTick="Timer1_Tick" />
<asp:UpdatePanel ID="up" runat="server">
  <ContentTemplate><asp:Label ID="lblClock" runat="server" /></ContentTemplate>
  <Triggers><asp:AsyncPostBackTrigger ControlID="Timer1" EventName="Tick" /></Triggers>
</asp:UpdatePanel>

Kestrel

Kestrel is the cross-platform, lightweight, high-performance web server built into ASP.NET Core. It is based on libuv/sockets, handles HTTP requests directly and is the default server for every ASP.NET Core application. It can run on its own (edge server) or behind a reverse proxy such as IIS, Nginx or Apache, which adds security, load balancing, SSL and static-file features.

Kestrel vs IIS

Class vs interface

Need for serialization

Serialization converts an object (its state) into a stream of bytes or text (binary, XML, JSON) so that it can be:

• saved to a file or database and restored later (persistence),
• sent across a network or between applications (remoting, web services),
• copied (deep clone) or kept in session state.

Deserialization rebuilds the object from the stream. Without it, each field would have to be written and read manually.

Program: save student records to student.txt and display them

using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;

[Serializable]
public class Student
{
    public int Roll { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
    public string Phone { get; set; }
}

class Program
{
    static void Main()
    {
        List<Student> list = new List<Student>();
        Console.Write("How many students? ");
        int n = int.Parse(Console.ReadLine());
        for (int i = 0; i < n; i++)
        {
            Student s = new Student();
            Console.Write("Roll: ");    s.Roll = int.Parse(Console.ReadLine());
            Console.Write("Name: ");    s.Name = Console.ReadLine();
            Console.Write("Address: "); s.Address = Console.ReadLine();
            Console.Write("Phone: ");   s.Phone = Console.ReadLine();
            list.Add(s);
        }

        // serialize to file
        File.WriteAllText("student.txt", JsonSerializer.Serialize(list));

        // deserialize and display
        string json = File.ReadAllText("student.txt");
        List<Student> saved = JsonSerializer.Deserialize<List<Student>>(json);
        Console.WriteLine("\nRoll\tName\tAddress\tPhone");
        foreach (Student s in saved)
            Console.WriteLine("{0}\t{1}\t{2}\t{3}", s.Roll, s.Name, s.Address, s.Phone);
    }
}

Advantages of ASP.NET MVC

• Separation of concerns: Model, View and Controller are independent, so code is easier to maintain.
• Testability: controllers and models can be unit tested without the UI.
• Full control over HTML and no ViewState or server-control lifecycle, which gives lighter pages.
• Clean, SEO-friendly URLs through routing (/Product/Details/5).
• Parallel development by UI, logic and data teams.
• Supports TDD, dependency injection, Razor views, filters, and works well with JavaScript frameworks and Web API.
• Extensible and scalable.

State management techniques in ASP.NET

HTTP is stateless, so state is kept by the following techniques.

Client-side:

1. ViewState: page and control values stored in a hidden field (ViewState["k"] = v), valid only for the same page.
2. Hidden fields: values in <input type="hidden">.
3. Cookies: small text data in the browser (Response.Cookies["name"].Value = "x"), which can persist across sessions.
4. Query string: data in the URL (page.aspx?id=5), visible and limited in size.
5. Control state: a protected form of ViewState for essential control data.

Server-side:

6. Session state: per-user data on the server (Session["user"] = "Ram"), with a timeout, kept in-proc, State Server or SQL Server.
7. Application state: global data shared by all users (Application["count"]).
8. Cache: data stored on the server for reuse, with expiry.
9. TempData / ViewBag / ViewData (MVC): pass data between controller and view. TempData survives a redirect.
10. Database: persistent storage for important data.

Client-side methods reduce server load but are less secure. Server-side methods are more secure but use server memory.

Validation control

A validation control checks the data a user enters in an input control before it is processed, so wrong or missing values are caught on the client (JavaScript) and again on the server. This keeps data accurate and the application secure. Each validator is attached to an input control by ControlToValidate and shows an ErrorMessage.

Validation controls in ASP.NET

1. RequiredFieldValidator: the field must not be empty.
2. CompareValidator: compares a value with another control or a constant (Operator, Type), for example password confirmation.
3. RangeValidator: value must lie between MinimumValue and MaximumValue.
4. RegularExpressionValidator: value must match a pattern (email, phone).
5. CustomValidator: user-defined client or server logic.
6. ValidationSummary: displays all validation errors in one place.

Program

<form id="form1" runat="server">
  Name: <asp:TextBox ID="txtName" runat="server" />
  <asp:RequiredFieldValidator ID="rfv" runat="server" ControlToValidate="txtName"
        ErrorMessage="Name is required" ForeColor="Red" Display="Dynamic" /><br />

  Age: <asp:TextBox ID="txtAge" runat="server" />
  <asp:RangeValidator ID="rv" runat="server" ControlToValidate="txtAge"
        MinimumValue="18" MaximumValue="60" Type="Integer"
        ErrorMessage="Age must be 18-60" ForeColor="Red" Display="Dynamic" /><br />

  Email: <asp:TextBox ID="txtEmail" runat="server" />
  <asp:RegularExpressionValidator ID="rev" runat="server" ControlToValidate="txtEmail"
        ValidationExpression="\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*"
        ErrorMessage="Invalid email" ForeColor="Red" Display="Dynamic" /><br />

  Password: <asp:TextBox ID="txtPass" runat="server" TextMode="Password" />
  Confirm: <asp:TextBox ID="txtConfirm" runat="server" TextMode="Password" />
  <asp:CompareValidator ID="cv" runat="server" ControlToValidate="txtConfirm"
        ControlToCompare="txtPass" Operator="Equal"
        ErrorMessage="Passwords do not match" ForeColor="Red" /><br />

  <asp:ValidationSummary ID="vs" runat="server" HeaderText="Please correct:" />
  <asp:Button ID="btnSubmit" runat="server" Text="Submit" OnClick="btnSubmit_Click" />
  <asp:Label ID="lblMsg" runat="server" />
</form>

protected void btnSubmit_Click(object sender, EventArgs e)
{
    if (Page.IsValid)                       // server-side check
        lblMsg.Text = "Form submitted successfully.";
}