Variables & Data Types

var message = "Hello World"; // Compiler knows this is a string
var count = 10;            // Compiler knows this is an int

int myInt = 9;
double myDouble = myInt; // Automatic: int becomes double

double myDouble = 9.78;
int myInt = (int)myDouble; // Manual: 9.78 becomes 9 (decimals are dropped)

const double Pi = 3.14159;
const string CompanyName = "TechCorp Inc";

// Pi = 3.15; // ❌ This will cause a compile-time error

Operators & Expressions

int score = 100;

score += 10; // Same as: score = score + 10; (110)
score -= 5;   // Same as: score = score - 5;   (105)
score *= 2;   // Same as: score = score * 2;   (210)
score /= 10;  // Same as: score = score / 10;  (21)

int age = 20;
string status = (age >= 18) ? "Adult" : "Minor";
// If age >= 18 is true, result is "Adult". Otherwise, "Minor".

string input = null;
string displayName = input ?? "Guest User";
// If input is null, displayName becomes "Guest User".

Control Flow: Decision Making

int userAge = 20;

if (userAge >= 21) 
{
    Console.WriteLine("Access Granted: Full Access.");
} 
else if (userAge >= 18) 
{
    Console.WriteLine("Access Granted: Limited Access.");
} 
else 
{
    Console.WriteLine("Access Denied: Underage.");
}

string role = "Admin";

switch (role)
{
    case "Admin":
        Console.WriteLine("Full System Access.");
        break; 
    case "Editor":
        Console.WriteLine("Content Management Access.");
        break;
    case "Guest":
        Console.WriteLine("Read-Only Access.");
        break;
    default:
        Console.WriteLine("Unknown Role: Access Denied.");
        break;
}

int dayNumber = 3;

string dayName = dayNumber switch
{
    1 => "Monday",
    2 => "Tuesday",
    3 => "Wednesday",
    4 => "Thursday",
    5 => "Friday",
    _ => "Weekend" // The underscore (_) is the default case
};

Console.WriteLine($"Today is {dayName}");

if (user != null) {
    if (user.IsActive) {
        if (user.HasPermission) {
            // Do the actual work here...
        }
    }
}

if (user == null) return; 
if (!user.IsActive) return;
if (!user.HasPermission) return;

// Do the actual work here... (The code stays flat!)

Loops: Mastering Iteration

// Structure: (Initialization; Condition; Iterator)
for (int i = 0; i < 5; i++) 
{
    Console.WriteLine($"Processing item number: {i}");
}

bool isRunning = true;
while (isRunning) 
{
    Console.WriteLine("System is scanning...");
    // Logic to eventually set isRunning = false;
}

string input;
do 
{
    Console.WriteLine("Please enter 'exit' to stop:");
    input = Console.ReadLine();
} while (input != "exit");

string[] employees = { "Alice", "Bob", "Charlie" };

foreach (var name in employees) 
{
    Console.WriteLine($"Sending email to: {name}");
}

for (int i = 1; i <= 10; i++) 
{
    if (i == 3) continue; // Skip 3
    if (i == 7) break;    // Stop entirely at 7
    
    Console.WriteLine(i); // Output: 1, 2, 4, 5, 6
}

Methods & Parameters

What Are Methods?

Methods are reusable blocks of code that perform a specific task. Instead of writing the same logic multiple times, we place that logic inside a method and call it whenever needed.

Methods help make programs:

• Cleaner and easier to read
• Reusable and modular
• Easier to debug and maintain
• More organized in large applications

void SayHello() {
    Console.WriteLine("Hello World");
}

Once defined, the method can be called anywhere in the program:

SayHello();
SayHello();
SayHello();

Defining Methods

A method definition usually contains:

• Access modifier (optional)
• Return type
• Method name
• Parameters
• Method body

static int Add(int x, int y) => x + y;

void Greet(string name, string title = "Dr.") {
    Console.WriteLine($"Hello {title} {name}");
}

Understanding Return Types

The return type tells C# what kind of value the method sends back.

• int → returns a whole number
• double → returns decimal values
• string → returns text
• bool → returns true or false
• void → returns nothing

int Square(int number) {
    return number * number;
}

Calling the method:

int result = Square(5);

Console.WriteLine(result);

Method Parameters

Parameters allow methods to receive data from outside. They act like variables that belong to the method.

void DisplayUser(string username, int age) {
    Console.WriteLine(username);
    Console.WriteLine(age);
}

Passing arguments into the method:

DisplayUser("Alex", 22);

Default Parameters

Default parameters provide fallback values when an argument is not supplied. This makes methods more flexible.

void Welcome(string name = "Guest") {
    Console.WriteLine($"Welcome {name}");
}

Welcome();
Welcome("Emma");

Expression-Bodied Methods

Small methods can be shortened using the lambda-style arrow syntax. This creates cleaner and shorter code.

int Multiply(int a, int b) => a * b;

Method Overloading

C# allows multiple methods with the same name as long as their parameters are different.

int Add(int a, int b) {
    return a + b;
}

double Add(double a, double b) {
    return a + b;
}

The compiler automatically selects the correct version.

Pass By Value

By default, C# passes arguments by value. This means the method receives a copy of the data.

void ChangeNumber(int num) {
    num = 100;
}

int value = 10;

ChangeNumber(value);

Console.WriteLine(value);

Output:

10

The original variable remains unchanged because only a copy was modified.

Using ref Parameters

The ref keyword passes variables by reference, allowing the method to directly modify the original variable.

void Increase(ref int number) {
    number++;
}

int score = 5;

Increase(ref score);

Console.WriteLine(score);

Using out Parameters

The out keyword is used when a method needs to return multiple values.

void GetValues(out int x, out int y) {
    x = 10;
    y = 20;
}

GetValues(out int a, out int b);

Console.WriteLine(a);
Console.WriteLine(b);

Local Methods

Methods can also exist inside another method. These are called local methods.

void MainMethod() {

    void PrintMessage() {
        Console.WriteLine("Inside Local Method");
    }

    PrintMessage();
}

Best Practices

• Keep methods short and focused
• Use meaningful method names
• Avoid methods that do too many tasks
• Reuse methods whenever possible
• Use parameters instead of hardcoded values

Common Mistakes

• Forgetting the return statement
• Using the wrong return type
• Passing incorrect argument types
• Creating methods with too many parameters
• Not understanding value vs reference passing

Mini Practice

Try creating the following methods yourself:

• A method that calculates area of a rectangle
• A method that checks if a number is even
• A method that prints a full name
• A method with a default parameter
• A method using ref or out

Collections & LINQ

What Are Collections?

Collections are data structures used to store and manage groups of objects. Instead of creating multiple individual variables, collections allow us to organize related data efficiently.

C# provides several built-in collection types that are powerful, flexible, and easy to use.

• Arrays
• Lists
• Dictionaries
• Queues
• Stacks
• HashSets

Why Use Collections?

Collections help developers work with large amounts of data dynamically. They make programs cleaner and more scalable.

• Store multiple values together
• Add or remove data dynamically
• Search and sort efficiently
• Loop through items easily
• Organize related information

Working with Lists

A List<T> is one of the most commonly used collections in C#. Unlike arrays, lists can grow and shrink dynamically.

var numbers = new List<int> { 10, 20, 30, 40 };

numbers.Add(50);

numbers.RemoveAt(0);

After removing the first element, the list becomes:

20, 30, 40, 50

Adding Items to a List

Use the Add() method to insert new items into a list.

var fruits = new List<string>();

fruits.Add("Apple");
fruits.Add("Banana");
fruits.Add("Orange");

Accessing List Elements

List items are accessed using indexes. Indexes start from 0.

Console.WriteLine(fruits[0]);

Console.WriteLine(fruits[1]);

Looping Through Lists

Lists are commonly used with loops to process every item.

foreach (var item in fruits) {
    Console.WriteLine(item);
}

Useful List Methods

Using Dictionaries

Dictionaries store data as key-value pairs. They are useful when each item has a unique identifier.

var students = new Dictionary<int, string>();

students.Add(1, "John");
students.Add(2, "Emma");

Console.WriteLine(students[1]);

Understanding LINQ

LINQ stands for Language Integrated Query. It allows developers to query collections using simple and readable syntax.

LINQ works with:

• Lists
• Arrays
• Dictionaries
• Databases
• XML data

Introduction to LINQ

LINQ (Language Integrated Query) allows you to query collections like SQL.

var highScores = numbers
    .Where(n => n > 25)
    .OrderByDescending(n => n);

This query:

• Filters numbers greater than 25
• Sorts them in descending order

The Where() Method

Where() filters data based on a condition.

var evenNumbers = numbers.Where(n => n % 2 == 0);

Only even numbers will be selected.

The Select() Method

Select() transforms data into another form.

var squared = numbers.Select(n => n * n);

This creates a new collection with squared values.

Sorting Data with LINQ

LINQ provides easy methods for sorting collections.

var ascending = numbers.OrderBy(n => n);

var descending = numbers.OrderByDescending(n => n);

Finding Data

LINQ can quickly search for matching values.

var firstLargeNumber = numbers.First(n => n > 25);

The first number greater than 25 will be returned.

Counting Items

The Count() method returns the total number of matching items.

int total = numbers.Count();

int evenCount = numbers.Count(n => n % 2 == 0);

Combining LINQ Methods

Multiple LINQ methods can be chained together for powerful queries.

var result = numbers
    .Where(n => n > 10)
    .OrderBy(n => n)
    .Select(n => n * 2);

Deferred Execution

Most LINQ queries use deferred execution. This means the query runs only when the data is actually used.

var query = numbers.Where(n => n > 20);

Console.WriteLine(query.Count());

Common LINQ Methods

Best Practices

• Use collections instead of many separate variables
• Choose the correct collection type for the task
• Keep LINQ queries readable
• Avoid overly complex chained queries
• Use meaningful variable names

Common Mistakes

• Using the wrong collection type
• Forgetting indexes start at 0
• Modifying collections during iteration
• Writing unreadable LINQ chains
• Ignoring null values in queries

Mini Practice

Try creating the following:

• A list of student names
• A dictionary of product prices
• A LINQ query that finds even numbers
• A query that sorts numbers descending
• A query using both Where() and Select()

Strings & Formatting

What Are Strings?

A string is a sequence of characters used to store text. Strings are one of the most commonly used data types in C#.

Examples of strings:

• Names
• Email addresses
• Messages
• User input
• File paths

string name = "John";

string message = "Welcome to C#";

Creating Strings

Strings are written inside double quotation marks.

string city = "London";

string language = "C#";

String Manipulation

C# provides many built-in methods for modifying and working with strings.

string text = "  C# Programming  ";

Console.WriteLine(text.Trim().ToUpper());

Console.WriteLine(text.Contains("C#"));

This example:

• Removes extra spaces using Trim()
• Converts text to uppercase using ToUpper()
• Checks if text contains a value using Contains()

Common String Methods

Converting Case

Strings can easily be converted between uppercase and lowercase.

string word = "Programming";

Console.WriteLine(word.ToUpper());

Console.WriteLine(word.ToLower());

Replacing Text

The Replace() method changes parts of a string.

string sentence = "I like Java";

sentence = sentence.Replace("Java", "C#");

Console.WriteLine(sentence);

Extracting Text

The Substring() method extracts a portion of a string.

string value = "Programming";

Console.WriteLine(value.Substring(0, 4));

Output:

Prog

Escaping Characters

Escape characters allow special characters inside strings.

Console.WriteLine("She said \"Hello\"");

Console.WriteLine("C:\\Projects\\App");

Verbatim Strings

Verbatim strings use the @ symbol to preserve formatting.

string path = @"
C:\Projects\MyApp\data.txt";

Console.WriteLine(path);

String Concatenation

Concatenation means joining strings together.

string firstName = "John";

string lastName = "Doe";

string fullName = firstName + " " + lastName;

Console.WriteLine(fullName);

String Interpolation

String interpolation is a cleaner way to insert variables into strings.

Console.WriteLine($"Date: {DateTime.Now:d}");

Console.WriteLine($"Price: {19.99:C}"); // Currency

The $ symbol allows variables and expressions inside curly braces.

Formatting Values

C# supports formatting numbers, dates, and currency values.

double price = 99.95;

Console.WriteLine($"{price:C}");

Console.WriteLine($"{price:N2}");

Console.WriteLine($"{price:P}");

Working with String Length

The Length property returns the number of characters.

string username = "Admin";

Console.WriteLine(username.Length);

Splitting Strings

The Split() method separates text into multiple parts.

string data = "HTML,CSS,JavaScript";

var skills = data.Split(',');

foreach (var skill in skills) {
    Console.WriteLine(skill);
}

Comparing Strings

Strings can be compared using comparison operators or helper methods.

string a = "C#";

string b = "c#";

Console.WriteLine(a == b);

Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));

String Immutability

Strings in C# are immutable. This means their contents cannot be changed after creation.

Methods like Replace() or ToUpper() create new strings instead of modifying the original one.

string textValue = "hello";

string upper = textValue.ToUpper();

Console.WriteLine(textValue);

Console.WriteLine(upper);

Best Practices

• Use meaningful variable names
• Prefer string interpolation over concatenation
• Trim user input when necessary
• Use formatting for readable output
• Keep string operations simple and readable

Common Mistakes

• Forgetting escape characters
• Using invalid indexes in Substring()
• Ignoring whitespace in user input
• Comparing strings with incorrect casing
• Confusing immutable behavior

Mini Practice

Try creating programs that:

• Convert text to uppercase
• Replace words in a sentence
• Display formatted prices
• Split a CSV string into values
• Create a formatted welcome message using interpolation

Object-Oriented Programming

Welcome, class. Today we deep-dive into the foundational architecture of scalable software design: Object-Oriented Programming (OOP). As software systems grow in complexity, linear, procedural code inevitably collapses under its own weight. OOP provides us with a framework to manage this complexity by partitioning our programs into self-contained, reusable modules modeled after real-world entities.

The Conceptual Paradigm: Blueprints vs. Artifacts

Before looking at the syntax, you must master the fundamental distinction between a Class and an Object:

• The Class (The Blueprint): This is an abstract data type. It defines the structure, capabilities, and rules of engagement, but it consumes no operational memory for data storage. It is merely a design.
• The Object (The Instance): This is the concrete artifact generated from that blueprint. It lives dynamically within your system's RAM, maintaining its own unique state.

Consider the architectural example below written in C#. Here, we define a baseline archetype (Person) and a specialized extension of that archetype (Developer).

public class Person {
    public string Name { get; set; }
    public virtual void Work() => Console.WriteLine("Working...");
}

public class Developer : Person {
    public override void Work() => Console.WriteLine("Coding...");
}

Anatomy of the Mechanics: Inheritance & Polymorphism

Let us break down the underlying mechanics of this code slice. Notice the use of the : operator in Developer : Person. This establishes an IS-A relationship (Inheritance). A Developer is a Person, meaning it automatically inherits the Name property without explicit redeclaration.

However, the real magic happens within the execution behavior, driven by two critical keywords:

1. virtual: Declared in the base class, this signals to the compiler that this method's behavior is fluid and can be intercepted by derived child classes.
2. override: Declared in the subclass, this actively intercepts the runtime execution path, substituting the base behavior with a specialized implementation.

Advanced Execution: Dynamic Binding in Action

To fully appreciate why this matters to a software architect, look at how the runtime engine processes these objects when grouped together. Because of polymorphism, a collection typed to the base class can hold any derived class instance seamlessly.

List<Person> team = new List<Person>() {
    new Person { Name = "Professor Smith" },
    new Developer { Name = "Grace Hopper" }
};

foreach (var member in team) {
    Console.Write(member.Name + " execution path: ");
    member.Work(); 
}

When this loop runs, the output demonstrates Dynamic Binding (or late binding). The system determines which method to call at runtime based on the actual object type, not the variable type:

Professor Smith execution path: Working...
Grace Hopper execution path: Coding...

Professor's Lab Task: Expanding the Ecosystem

To reinforce today's lecture, you must complete a practical coding task. Your goal is to introduce a third tier to our organizational hierarchy that introduces unique tracking and alters behavior appropriately.

Your Instructions:

• Create a new class named Manager that inherits directly from Person.
• Add an exclusive property to the Manager class: TeamSize (an integer type).
• Override the Work() method so that it outputs: "Managing a team of [TeamSize] people..." instead of the generic response.

public class Manager : Person {
    // 1. Task: Define your TeamSize property here
    
    // 2. Task: Override the Work() method using string interpolation
}

Verify your solution by creating an instance of your Manager, assigning it a TeamSize of 5, adding it to the team list created above, and confirming that the output shifts dynamically at runtime.

Exceptions & File I/O

Handling Errors

try {
    int x = int.Parse(Console.ReadLine());
} catch (FormatException ex) {
    Console.WriteLine("Invalid number format.");
} finally {
    Console.WriteLine("Done.");
}

Reading/Writing Files

File.WriteAllText("log.txt", "Hello C#");
string content = File.ReadAllText("log.txt");

The .NET Ecosystem

NuGet & Libraries

Use dotnet add package to install community libraries like Newtonsoft.Json.

Asynchronous Programming

public async Task<string> GetDataAsync() {
    var client = new HttpClient();
    return await client.GetStringAsync("https://api.example.com");
}

Capstone Project: Task Manager

Build a console-based Task Manager that uses everything we've learned: Lists, LINQ, OOP, and File I/O.

// Project requirements:
// 1. Add/Remove tasks
// 2. Mark tasks as complete
// 3. Save tasks to tasks.json
// 4. Filter tasks using LINQ

Async & Await

Content coming soon...

Delegates & Events

Content coming soon...

Generics & Interfaces

Content coming soon...

Entity Framework & Databases

Content coming soon...

Unit Testing (xUnit)

Content coming soon...

Final Project — .NET Web API

Content coming soon...