**Course Title:** Mastering C#: From Fundamentals to Advanced Programming **Section Title:** Advanced OOP: Interfaces, Abstract Classes, and Generics **Topic:** Build a system using abstract classes and interfaces to demonstrate OOP principles.(Lab topic) In this lab topic, we'll design and implement a simple banking system that showcases the application of abstract classes and interfaces in C#. Our goal is to demonstrate the principles of object-oriented programming (OOP) in a real-world scenario. **Lab Overview** Our banking system will consist of the following components: * **Account**: An abstract class representing a basic bank account. * **CheckingAccount**: A concrete class inheriting from `Account`, representing a checking account. * **SavingsAccount**: A concrete class inheriting from `Account`, representing a savings account. * **Bank**: A class that manages a collection of accounts. * **IBankOperations**: An interface defining the operations that can be performed on an account. * **AccountManager**: A class implementing `IBankOperations` to manage account operations. **Step 1: Define the `Account` Abstract Class** Create a new class called `Account` and mark it as `abstract`. We'll define the common properties and methods for all types of accounts in this class. The account number will be represented by a `Guid` and the account balance will be a `decimal` value. ```csharp public abstract class Account { public Guid AccountNumber { get; protected set; } public decimal Balance { get; protected set; } protected Account(Guid accountNumber, decimal initialBalance) { AccountNumber = accountNumber; Balance = initialBalance; } public virtual void Deposit(decimal amount) { Balance += amount; } public virtual void Withdraw(decimal amount) { if (amount > Balance) { throw new InvalidOperationException("Insufficient funds."); } Balance -= amount; } } ``` **Step 2: Define the `CheckingAccount` and `SavingsAccount` Concrete Classes** Create new classes `CheckingAccount` and `SavingsAccount` that inherit from the `Account` abstract class. These classes will represent specific types of bank accounts and may have additional properties and methods. ```csharp public class CheckingAccount : Account { public CheckingAccount(Guid accountNumber, decimal initialBalance) : base(accountNumber, initialBalance) { } public void ApplyFees(decimal fees) { if (fees > Balance) { throw new InvalidOperationException("Insufficient funds to apply fees."); } Balance -= fees; } } public class SavingsAccount : Account { public SavingsAccount(Guid accountNumber, decimal initialBalance) : base(accountNumber, initialBalance) { } public void AddInterest(decimal interestRate) { decimal interest = Balance * interestRate / 100; Balance += interest; } } ``` **Step 3: Define the `IBankOperations` Interface** Create a new interface called `IBankOperations` that defines the operations that can be performed on an account. These operations include depositing, withdrawing, and checking the account balance. ```csharp public interface IBankOperations { void Deposit(Guid accountNumber, decimal amount); void Withdraw(Guid accountNumber, decimal amount); decimal GetBalance(Guid accountNumber); } ``` **Step 4: Define the `AccountManager` Class** Create a new class called `AccountManager` that implements the `IBankOperations` interface. This class will manage the account operations and interact with the `Bank` class. ```csharp public class AccountManager : IBankOperations { private Bank bank; public AccountManager(Bank bank) { this.bank = bank; } public void Deposit(Guid accountNumber, decimal amount) { Account account = bank.GetAccount(accountNumber); if (account != null) { account.Deposit(amount); } else { throw new InvalidOperationException("Account not found."); } } public void Withdraw(Guid accountNumber, decimal amount) { Account account = bank.GetAccount(accountNumber); if (account != null) { account.Withdraw(amount); } else { throw new InvalidOperationException("Account not found."); } } public decimal GetBalance(Guid accountNumber) { Account account = bank.GetAccount(accountNumber); if (account != null) { return account.Balance; } else { throw new InvalidOperationException("Account not found."); } } } ``` **Step 5: Define the `Bank` Class** Create a new class called `Bank` that represents the bank and manages a collection of accounts. ```csharp public class Bank { private Dictionary<Guid, Account> accounts; public Bank() { accounts = new Dictionary<Guid, Account>(); } public void AddAccount(Account account) { accounts[account.AccountNumber] = account; } public Account GetAccount(Guid accountNumber) { return accounts.TryGetValue(accountNumber, out Account account) ? account : null; } } ``` **Conclusion** In this lab topic, we've built a simple banking system that demonstrates the application of abstract classes and interfaces in C#. We've defined abstract classes `Account` and concrete classes `CheckingAccount` and `SavingsAccount`. We've also defined an interface `IBankOperations` and implemented it in the `AccountManager` class. The `Bank` class manages a collection of accounts. This system showcases the principles of object-oriented programming (OOP) and demonstrates how abstract classes and interfaces can be used to design a real-world application. **External Resources:** * For more information on abstract classes and interfaces in C#, visit [Microsoft Documentation](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/abstract-and-sealed-classes-and-class-members). * To learn more about the principles of object-oriented programming, visit [Wikipedia](https://en.wikipedia.org/wiki/Object-oriented_programming). Please feel free to ask questions or request clarification on any of the concepts covered in this lab topic.