Detailed Description

Inheritance and polymorphism are two fundamental pillars of Object-Oriented Programming (OOP) that enable developers to write flexible, maintainable, and reusable code. Inheritance allows you to create new classes based on existing ones, establishing a hierarchical relationship where derived classes (also called child or subclasses) inherit properties and methods from base classes (also called parent or superclasses). This mechanism promotes code reuse by allowing you to define common functionality once in a base class and extend or specialize it in derived classes. Polymorphism, which literally means "many forms," enables objects of different types to be treated uniformly through a common interface while maintaining their unique behaviors. Together, these concepts form the backbone of designing scalable and extensible applications in C#.

Understanding inheritance and polymorphism is crucial for professional C# development because these concepts directly address real-world software design challenges. In enterprise applications, you often encounter scenarios where multiple entities share common characteristics but also have unique behaviors. For example, in a human resources system, you might have different types of employees—full-time, part-time, contractors—all sharing common properties like name and ID, but differing in how their salary is calculated. Inheritance allows you to model this naturally by creating an Employee base class with common properties, and derived classes that implement specific salary calculation logic. Polymorphism then enables you to process all employees uniformly through a collection of Employee references, while each object executes its appropriate salary calculation method. This approach significantly reduces code duplication, improves maintainability, and makes your codebase more adaptable to changing requirements.

At the heart of inheritance lies the concept of the IS-A relationship. When you create a derived class, you're establishing that the derived class "is a" specialized version of the base class. This relationship is crucial for understanding when inheritance is appropriate. Key terminology includes: base class (the parent class being inherited from), derived class (the child class inheriting from the base), virtual methods (methods in the base class that can be overridden), override methods (methods in derived classes that replace base class implementations), abstract classes (classes that cannot be instantiated and may contain abstract methods), and sealed classes (classes that cannot be inherited from). C# supports single inheritance, meaning a class can inherit from only one base class, but it can implement multiple interfaces, providing flexibility in design.

Polymorphism manifests in two primary forms in C#: compile-time polymorphism (method overloading and operator overloading) and runtime polymorphism (method overriding and virtual method dispatch). Runtime polymorphism, which this lesson emphasizes, allows the appropriate method to be called based on the actual type of the object at runtime, not the type of the reference variable. This is achieved through virtual methods marked with the virtual keyword in the base class and overridden using the override keyword in derived classes. The Common Language Runtime (CLR) uses a mechanism called dynamic dispatch to determine which method implementation to execute, enabling powerful design patterns and flexible code architectures.

Common use cases for inheritance and polymorphism include building plugin architectures, creating frameworks and libraries, implementing design patterns like Strategy and Template Method, developing game engines with various entity types, and constructing user interface component hierarchies. In data access layers, you might use inheritance to create a generic repository base class with common CRUD operations, then derive specialized repositories for specific entities. In financial applications, different types of accounts (checking, savings, investment) can inherit from a base Account class while implementing their own interest calculation or withdrawal rules.

By the end of this lesson, you will master the ability to design and implement class hierarchies using inheritance, understand when and how to use virtual, override, abstract, and sealed keywords appropriately, leverage polymorphism to write flexible and extensible code, recognize the difference between compile-time and runtime polymorphism, and apply best practices for creating maintainable object-oriented designs. You'll be equipped to evaluate design scenarios and make informed decisions about when to use inheritance versus composition, how to properly structure class hierarchies, and how to utilize polymorphism to write code that is both powerful and elegant. These skills are essential for advancing to more complex topics like design patterns and architectural principles.

Practical Examples

Example 1: Basic Inheritance with Virtual Methods

This example demonstrates fundamental inheritance concepts by creating a simple vehicle hierarchy. We'll explore how derived classes inherit members from base classes and how virtual methods enable polymorphic behavior.

using System;

namespace InheritanceBasics

{

// Base class representing a generic vehicle

public class Vehicle

{

// Properties inherited by all derived classes

public string Brand { get; set; }

public string Model { get; set; }

public int Year { get; set; }

// Constructor for initializing common properties

public Vehicle(string brand, string model, int year)

{

Brand = brand;

Model = model;

Year = year;

}

// Virtual method - can be overridden by derived classes

public virtual void StartEngine()

{

Console.WriteLine($"{Brand} {Model}: Engine starting with standard ignition...");

}

// Virtual method that derived classes can customize

public virtual string GetVehicleInfo()

{

return $"{Year} {Brand} {Model}";

}

// Non-virtual method - same behavior for all vehicles

public void DisplayBasicInfo()

{

Console.WriteLine($"Vehicle: {GetVehicleInfo()}");

}

}

// Derived class for cars - inherits from Vehicle

public class Car : Vehicle

{

public int NumberOfDoors { get; set; }

// Constructor calls base class constructor using 'base' keyword

public Car(string brand, string model, int year, int doors)

: base(brand, model, year)

{

NumberOfDoors = doors;

}

// Override the virtual method with specific behavior for cars

public override void StartEngine()

{

Console.WriteLine($"{Brand} {Model}: Car engine started. Ready to drive!");

}

// Override to provide more specific information

public override string GetVehicleInfo()

{

return $"{base.GetVehicleInfo()} - {NumberOfDoors} doors";

}

}

// Another derived class for motorcycles

public class Motorcycle : Vehicle

{

public bool HasSidecar { get; set; }

public Motorcycle(string brand, string model, int year, bool hasSidecar)

: base(brand, model, year)

{

HasSidecar = hasSidecar;

}

// Different implementation for motorcycles

public override void StartEngine()

{

Console.WriteLine($"{Brand} {Model}: Motorcycle roaring to life! Vroom!");

}

public override string GetVehicleInfo()

{

string sidecarInfo = HasSidecar ? "with sidecar" : "solo";

return $"{base.GetVehicleInfo()} - {sidecarInfo}";

}

}

class Program

{

static void Main(string[] args)

{

// Create instances of different vehicle types

Vehicle genericVehicle = new Vehicle("Generic", "Model-X", 2020);

Car sedan = new Car("Toyota", "Camry", 2023, 4);

Motorcycle sportBike = new Motorcycle("Harley-Davidson", "Street 750", 2022, false);

// Demonstrate polymorphism - all accessed through Vehicle reference

Vehicle[] vehicles = { genericVehicle, sedan, sportBike };

Console.WriteLine("=== Demonstrating Polymorphism ===\n");

foreach (Vehicle vehicle in vehicles)

{

vehicle.DisplayBasicInfo();

vehicle.StartEngine(); // Calls appropriate version based on actual type

Console.WriteLine();

}

}

}

}

Output:

=== Demonstrating Polymorphism ===

Vehicle: 2020 Generic Model-X

Generic Model-X: Engine starting with standard ignition...

Vehicle: 2023 Toyota Camry - 4 doors

Toyota Camry: Car engine started. Ready to drive!

Vehicle: 2022 Harley-Davidson Street 750 - solo

Harley-Davidson Street 750: Motorcycle roaring to life! Vroom!

Key Points:

The base keyword invokes the base class constructor, ensuring proper initialization
Virtual methods in the base class can be overridden to provide specialized behavior
Polymorphism allows treating different types uniformly through a common base reference
The appropriate method is called based on the actual object type, not the reference type

Example 2: Abstract Classes and Methods

Abstract classes provide a way to define common functionality while forcing derived classes to implement specific behaviors. This example demonstrates an employee payroll system using abstract classes.

using System;

using System.Collections.Generic;

namespace AbstractClassExample

{

// Abstract base class - cannot be instantiated directly

public abstract class Employee

{

public string FirstName { get; set; }

public string LastName { get; set; }

public string EmployeeId { get; set; }

// Constructor for common initialization

protected Employee(string firstName, string lastName, string employeeId)

{

FirstName = firstName;

LastName = lastName;

EmployeeId = employeeId;

}

// Abstract method - must be implemented by derived classes

public abstract decimal CalculateMonthlySalary();

// Abstract method for calculating benefits

public abstract decimal CalculateAnnualBonus();

// Concrete method - provides common functionality

public virtual void DisplayEmployeeInfo()

{

Console.WriteLine($"Employee ID: {EmployeeId}");

Console.WriteLine($"Name: {FirstName} {LastName}");

Console.WriteLine($"Type: {this.GetType().Name}");

}

// Template method pattern - defines algorithm structure

public void ProcessMonthlyPayroll()

{

Console.WriteLine("\n--- Processing Payroll ---");

DisplayEmployeeInfo();

decimal salary = CalculateMonthlySalary();

decimal monthlyBonus = CalculateAnnualBonus() / 12;

decimal total = salary + monthlyBonus;

Console.WriteLine($"Base Salary: ${salary:N2}");

Console.WriteLine($"Monthly Bonus Portion: ${monthlyBonus:N2}");

Console.WriteLine($"Total Monthly Pay: ${total:N2}");

}

}

// Full-time employee with fixed salary

public class FullTimeEmployee : Employee

{

public decimal AnnualSalary { get; set; }

public FullTimeEmployee(string firstName, string lastName,

string employeeId, decimal annualSalary)

: base(firstName, lastName, employeeId)

{

AnnualSalary = annualSalary;

}

// Implementation of abstract method

public override decimal CalculateMonthlySalary()

{

return AnnualSalary / 12;

}

// Full-time employees get 10% annual bonus

public override decimal CalculateAnnualBonus()

{

return AnnualSalary * 0.10m;

}

}

// Part-time employee paid hourly

public class PartTimeEmployee : Employee

{

public decimal HourlyRate { get; set; }

public int MonthlyHours { get; set; }

public PartTimeEmployee(string firstName, string lastName,

string employeeId, decimal hourlyRate, int monthlyHours)

: base(firstName, lastName, employeeId)

{

HourlyRate = hourlyRate;

MonthlyHours = monthlyHours;

}

public override decimal CalculateMonthlySalary()

{

return HourlyRate * MonthlyHours;

}

// Part-time employees get smaller bonus (5% of annual earnings)

public override decimal CalculateAnnualBonus()

{

decimal annualEarnings = HourlyRate * MonthlyHours * 12;

return annualEarnings * 0.05m;

}

// Additional method specific to part-time employees

public void UpdateMonthlyHours(int hours)

{

MonthlyHours = hours;

Console.WriteLine($"Monthly hours updated to {hours} for {FirstName} {LastName}");

}

}

// Contract employee with project-based payment

public class ContractEmployee : Employee

{

public decimal ProjectRate { get; set; }

public int ProjectsCompleted { get; set; }

public ContractEmployee(string firstName, string lastName,

string employeeId, decimal projectRate)

: base(firstName, lastName, employeeId)

{

ProjectRate = projectRate;

ProjectsCompleted = 0;

}

public override decimal CalculateMonthlySalary()

{

return ProjectRate * ProjectsCompleted;

}

// Contractors get performance-based bonus

public override decimal CalculateAnnualBonus()

{

// $500 bonus per project completed throughout the year

return ProjectsCompleted * 12 * 500;

}

public void CompleteProject()

{

ProjectsCompleted++;

Console.WriteLine($"{FirstName} {LastName} completed a project! Total: {ProjectsCompleted}");

}

}

class Program

{

static void Main(string[] args)

{

// Create different types of employees

var employees = new List

{

new FullTimeEmployee("John", "Smith", "FT001", 75000),

new PartTimeEmployee("Sarah", "Johnson", "PT001", 25, 80),

new ContractEmployee("Mike", "Williams", "CT001", 5000)

};

// Set some specific data

((ContractEmployee)employees[2]).CompleteProject();

((ContractEmployee)employees[2]).CompleteProject();

Console.WriteLine("========== MONTHLY PAYROLL PROCESSING ==========");

// Process payroll for all employees polymorphically

foreach (Employee employee in employees)

{

employee.ProcessMonthlyPayroll();

}

// Calculate total monthly payroll cost

Console.WriteLine("\n========== PAYROLL SUMMARY ==========");

decimal totalCost = 0;

foreach (Employee employee in employees)

{

decimal employeeCost = employee.CalculateMonthlySalary() +

(employee.CalculateAnnualBonus() / 12);

totalCost += employeeCost;

}

Console.WriteLine($"Total Monthly Payroll: ${totalCost:N2}");

}

}

}

Output:

Mike Williams completed a project! Total: 1

Mike Williams completed a project! Total: 2

========== MONTHLY PAYROLL PROCESSING ==========

--- Processing Payroll ---

Employee ID: FT001

Name: John Smith

Type: FullTimeEmployee

Base Salary: $6,250.00

Monthly Bonus Portion: $625.00

Total Monthly Pay: $6,875.00

--- Processing Payroll ---

Employee ID: PT001

Name: Sarah Johnson

Type: PartTimeEmployee

Base Salary: $2,000.00

Monthly Bonus Portion: $100.00

Total Monthly Pay: $2,100.00

--- Processing Payroll ---

Employee ID: CT001

Name: Mike Williams

Type: ContractEmployee

Base Salary: $10,000.00

Monthly Bonus Portion: $1,000.00

Total Monthly Pay: $11,000.00

========== PAYROLL SUMMARY ==========

Total Monthly Payroll: $19,975.00

Key Points:

Abstract classes cannot be instantiated but serve as base classes
Abstract methods must be implemented by all non-abstract derived classes
The Template Method pattern uses abstract methods within concrete methods
Protected constructors in abstract classes ensure proper initialization flow

Example 3: Method Overriding and the 'base' Keyword

This example explores advanced aspects of method overriding, including calling base class implementations and understanding the difference between virtual, override, and new keywords.

using System;

namespace MethodOverridingExample

{

// Base class representing a notification system

public class Notification

{

public string Message { get; set; }

public DateTime Timestamp { get; set; }

public Notification(string message)

{

Message = message;

Timestamp = DateTime.Now;

}

// Virtual method that can be overridden

public virtual void Send()

{

Console.WriteLine($"[{Timestamp:HH:mm:ss}] Sending notification: {Message}");

}

// Virtual method for formatting

public virtual string FormatMessage()

{

return $"Notification: {Message}";

}

// Virtual method to log the notification

public virtual void LogNotification()

{

Console.WriteLine($"LOG: Basic notification logged at {Timestamp}");

}

}

// Email notification extends base notification

public class EmailNotification : Notification

{

public string RecipientEmail { get; set; }

public string Subject { get; set; }

public EmailNotification(string message, string email, string subject)

: base(message)

{

RecipientEmail = email;

Subject = subject;

}

// Override Send method but also call base implementation

public override void Send()

{

// Call base class method first

base.Send();

// Then add email-specific logic

Console.WriteLine($" → Sending email to: {RecipientEmail}");

Console.WriteLine($" → Subject: {Subject}");

Console.WriteLine($" → Body: {FormatMessage()}");

Console.WriteLine(" → Email sent successfully!");

}

// Override to provide email-specific formatting

public override string FormatMessage()

{

// Get base formatting and enhance it

string baseFormat = base.FormatMessage();

return $"{baseFormat}\n---\nSent via Email Notification System";

}

// Override logging with email-specific details

public override void LogNotification()

{

base.LogNotification(); // Call base logging

Console.WriteLine($"LOG: Email sent to {RecipientEmail} with subject '{Subject}'");

}

}

// SMS notification with character limits

public class SmsNotification : Notification

{

public string PhoneNumber { get; set; }

private const int MaxSmsLength = 160;

public SmsNotification(string message, string phoneNumber)

: base(message)

{

PhoneNumber = phoneNumber;

}

public override void Send()

{

base.Send();

string smsMessage = FormatMessage();

if (smsMessage.Length > MaxSmsLength)

{

Console.WriteLine($" ⚠ Warning: Message truncated to {MaxSmsLength} characters");

smsMessage = smsMessage.Substring(0, MaxSmsLength);

}

Console.WriteLine($" → Sending SMS to: {PhoneNumber}");

Console.WriteLine($" → Message: {smsMessage}");

Console.WriteLine($" → SMS sent successfully!");

}

public override string FormatMessage()

{

// SMS messages are more concise

return $"SMS: {Message}";

}

public override void LogNotification()

{

base.LogNotification();

Console.WriteLine($"LOG: SMS sent to {PhoneNumber} ({Message.Length} chars)");

}

}

// Push notification for mobile apps

public class PushNotification : Notification

{

public string DeviceToken { get; set; }

public string AppName { get; set; }

public int Priority { get; set; } // 1-5, 5 being highest

public PushNotification(string message, string deviceToken, string appName, int priority)

: base(message)

{

DeviceToken = deviceToken;

AppName = appName;

Priority = Math.Clamp(priority, 1, 5); // Ensure valid range

}

public override void Send()

{

base.Send();

Console.WriteLine($" → Sending push notification to device: {DeviceToken.Substring(0, 8)}...");

Console.WriteLine($" → App: {AppName}");

Console.WriteLine($" → Priority: {new string('★', Priority)}{new string('☆', 5 - Priority)}");

Console.WriteLine($" → Content: {FormatMessage()}");

if (Priority >= 4)

{

Console.WriteLine(" → HIGH PRIORITY - Notification will bypass Do Not Disturb");

}

Console.WriteLine(" → Push notification delivered!");

}

public override string FormatMessage()

{

return $"[{AppName}] {Message}";

}

public override void LogNotification()

{

base.LogNotification();

Console.WriteLine($"LOG: Push notification sent to {AppName} (Priority: {Priority})");

}

}

class Program

{

static void Main(string[] args)

{

// Create various notification types

Notification[] notifications = new Notification[]

{

new Notification("System maintenance scheduled"),

new EmailNotification(

"Your order has been shipped!",

"customer@example.com",

"Order Shipment Confirmation"

),

new SmsNotification(

"Your verification code is: 123456. Valid for 10 minutes.",

"+1-555-0123"

),

new PushNotification(

"You have a new message from Sarah",

"abc123xyz789device",

"ChatApp",

5

)

};

Console.WriteLine("========== SENDING NOTIFICATIONS ==========\n");

// Demonstrate polymorphism with different notification types

foreach (Notification notification in notifications)

{

notification.Send();

Console.WriteLine();

}

Console.WriteLine("\n========== NOTIFICATION LOGS ==========\n");

// Demonstrate polymorphic logging

foreach (Notification notification in notifications)

{

notification.LogNotification();

Console.WriteLine();

}

}

}

}

Key Points:

The base keyword allows calling parent class implementations
Override methods can extend base functionality rather than completely replacing it
Polymorphism enables processing different notification types through a common interface
Each derived class maintains its unique behavior while sharing common structure

Example 4: Sealed Classes and Methods

This example demonstrates the use of sealed classes and methods to prevent further inheritance or overriding, which is important for security and design integrity.

using System;

namespace SealedExample

{

// Base class for shapes

public class Shape

{

public string Name { get; set; }

public Shape(string name)

{

Name = name;

}

// Virtual method that can be overridden

public virtual double CalculateArea()

{

return 0;

}

// Virtual method for perimeter

public virtual double CalculatePerimeter()

{

return 0;

}

public virtual void DisplayInfo()

{

Console.WriteLine($"Shape: {Name}");

Console.WriteLine($"Area: {CalculateArea():F2}");

Console.WriteLine($"Perimeter: {CalculatePerimeter():F2}");

}

}

// Rectangle class with virtual methods

public class Rectangle : Shape

{

public double Width { get; set; }

public double Height { get; set; }

public Rectangle(double width, double height) : base("Rectangle")

{

Width = width;

Height = height;

}

// Override and seal to prevent further overriding in derived classes

public sealed override double CalculateArea()

{

return Width * Height;

}

// This override is NOT sealed, allowing further overriding

public override double CalculatePerimeter()

{

return 2 * (Width + Height);

}

public override void DisplayInfo()

{

Console.WriteLine($"Rectangle (Width: {Width}, Height: {Height})");

base.DisplayInfo();

}

}

// Square derives from Rectangle

public class Square : Rectangle

{

public Square(double side) : base(side, side)

{

Name = "Square";

}

// CANNOT override CalculateArea() because it's sealed in Rectangle

// Uncommenting below would cause compilation error:

// public override double CalculateArea() { return Width * Width; }

// CAN override CalculatePerimeter() because it's not sealed

public override double CalculatePerimeter()

{

// Optimize calculation for square

return 4 * Width;

}

public override void DisplayInfo()

{

Console.WriteLine($"Square (Side: {Width})");

Console.WriteLine($"Area: {CalculateArea():F2}");

Console.WriteLine($"Perimeter: {CalculatePerimeter():F2}");

}

}

// Sealed class - cannot be inherited from

public sealed class Circle : Shape

{

public double Radius { get; set; }

public Circle(double radius) : base("Circle")

{

Radius = radius;

}

public override double CalculateArea()

{

return Math.PI * Radius * Radius;

}

public override double CalculatePerimeter()

{

return 2 * Math.PI * Radius;

}

public override void DisplayInfo()

{

Console.WriteLine($"Circle (Radius: {Radius})");

base.DisplayInfo();

}

}

// This would cause a compilation error because Circle is sealed:

// public class Ellipse : Circle { }

// Sealed class for secure configuration

public sealed class SecurityConfiguration

{

private static SecurityConfiguration _instance;

// Private constructor prevents instantiation and inheritance

private SecurityConfiguration()

{

EncryptionKey = GenerateEncryptionKey();

}

public static SecurityConfiguration Instance

{

get

{

if (_instance == null)

{

_instance = new SecurityConfiguration();

}

return _instance;

}

}

public string EncryptionKey { get; private set; }

private string GenerateEncryptionKey()

{

// Simplified key generation

return Convert.ToBase64String(Guid.NewGuid().ToByteArray());

}

public void DisplayConfiguration()

{

Console.WriteLine("\n--- Security Configuration ---");

Console.WriteLine($"Encryption Key: {EncryptionKey.Substring(0, 8)}...");

Console.WriteLine("Configuration is sealed and cannot be inherited");

}

}

class Program

{

static void Main(string[] args)

{

Console.WriteLine("========== SEALED METHODS DEMONSTRATION ==========\n");

// Create different shapes

Shape[] shapes = new Shape[]

{

new Rectangle(5, 10),

new Square(7),

new Circle(4)

};

// Process all shapes polymorphically

foreach (Shape shape in shapes)

{

shape.DisplayInfo();

Console.WriteLine();

}

Console.WriteLine("========== KEY POINTS ABOUT SEALED ==========");

Console.WriteLine("1. Square cannot override Rectangle's CalculateArea() - it's sealed");

Console.WriteLine("2. Square CAN override Rectangle's CalculatePerimeter() - not sealed");

Console.WriteLine("3. Circle cannot be inherited from - the class is sealed");

Console.WriteLine("4. Sealed classes are often used for security and singleton patterns\n");

// Demonstrate sealed class for security

SecurityConfiguration config = SecurityConfiguration.Instance;

config.DisplayConfiguration();

// Attempting to inherit from Circle or SecurityConfiguration would fail at compile time

Console.WriteLine("\n========== BENEFITS OF USING SEALED ==========");

Console.WriteLine("✓ Prevents unauthorized inheritance");

Console.WriteLine("✓ Improves performance (compiler optimizations)");

Console.WriteLine("✓ Guarantees behavior cannot be changed by derived classes");

Console.WriteLine("✓ Enforces design decisions and maintains integrity");

}

}

}

Output:

========== SEALED METHODS DEMONSTRATION ==========

Rectangle (Width: 5, Height: 10)

Shape: Rectangle

Area: 50.00

Perimeter: 30.00

Square (Side: 7)

Area: 49.00

Perimeter: 28.00

Circle (Radius: 4)

Shape: Circle

Area: 50.27

Perimeter: 25.13

========== KEY POINTS ABOUT SEALED ==========

1. Square cannot override Rectangle's CalculateArea() - it's sealed

2. Square CAN override Rectangle's CalculatePerimeter() - not sealed

3. Circle cannot be inherited from - the class is sealed

4. Sealed classes are often used for security and singleton patterns

--- Security Configuration ---

Encryption Key: 8kFmJ3A=...

Configuration is sealed and cannot be inherited

========== BENEFITS OF USING SEALED ==========

✓ Prevents unauthorized inheritance

✓ Improves performance (compiler optimizations)

✓ Guarantees behavior cannot be changed by derived classes

✓ Enforces design decisions and maintains integrity

Key Points:

Sealed methods prevent derived classes from overriding specific methods
Sealed classes cannot be inherited, ensuring design integrity
Use sealed for security-critical classes and performance optimization
Sealed is commonly used in singleton patterns and immutable configurations

Practice Exercises

Exercise 1: Banking System (Easy)

Requirements:

Create a simple banking system with a base BankAccount class and two derived classes: SavingsAccount and CheckingAccount. Implement the following:

Base class should have properties for account number, holder name, and balance
Include virtual methods for Deposit, Withdraw, and DisplayAccountInfo
SavingsAccount should have an interest rate and a method to calculate interest
CheckingAccount should have an overdraft limit and allow withdrawals up to that limit
Override Withdraw method differently for each account type
Create at least one account of each type and demonstrate polymorphic behavior

Expected Outcomes:

Pure C# from basic to advanced

Module 1: C# Fundamentals and Syntax

Module 2: Object-Oriented Programming in C#

Module 3: C# Data Structures and Algorithms

Module 4: Error Handling and Debugging in C#

Module 5: C# Best Practices and Design Patterns

Module 6: Advanced C# Topics and Optimization