проект из 7 главы, C#

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Microsoft (R) Visual C# Compiler version 2.9.0.63208 (958f2354)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    
    public class Program
    {
        public static void Main(string[] args)
        {
           
            Bank <Account> bank = new Bank <Account>("Название_банка");
            bool alive =true;
            while(alive)
               {
                  ConsoleColor color = Console.ForegroundColor;
                  Console.ForegroundColor = ConsoleColor.DarkGreen; // выводит список команд зелёным цветом
                Console.WriteLine("1. Открыть счет \t 2. Вывести средства  \t 3. Добавить на счет");
                 Console.WriteLine("4. Закрыть счет \t 5. Пропустить день \t 6. Выйти из программы");
                Console.WriteLine("Введите номер пункта:");
                Console.ForegroundColor = color;
             try
                {
                    int command = Convert.ToInt32(Console.ReadLine());
                 
                   switch (command)
                   {
                       case 1: 
                    OpenAccount(bank);
                    break;
                    
                                       
                    case 2: 
                    Withdraw(bank);
                    break;
                    
                    case 3: 
                    Put(bank);
                    break;
                    
                    case 4: 
                    CloseAccount(bank);
                    break;
                    
                    case 5: 
                    
                  break;
                    
                    case 6: 
                    alive=false;
                    continue;
          
                }
                bank.CalculatePercentage();
     
                }
            catch(Exception ex)
            {
                // сообщение об ошибке красным цветом.
                color = Console.ForegroundColor;
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(ex.Message);
                Console.ForegroundColor=color;
            }
                                               
        }
    }
    
    private static void OpenAccount(Bank<Account> bank)
    {
        Console.WriteLine("Укажите сумму для создания счета");
        
        decimal sum= Convert.ToDecimal(Console.ReadLine());
        Console.WriteLine("Выберите тип счета: 1. До востребования 2. Депозит");
        AccountType accountType;
        
        int type =Convert.ToInt32(Console.ReadLine());
        if(type ==2)
            accountType=AccountType.Deposit;
        else
              accountType=AccountType.Ordinary;
        
        bank.Open(accountType, 
                  sum,
                  AddSumHandler,  //обработчик добавления средств на счет
                  
                 WithdrawSumHandler, // обработчик вывода средств 
                  (o,e)=>Console.WriteLine(e.Message), // обработчик начислений процентов в виде лямбда-выражения
                  CloseAccountHandler, // обработчик закрытия счета
                  
                  OpenAccountHandler); // обработчик открытия счета
            
    }
    
    private static void Withdraw(Bank<Account> bank)
    {
      Console.WriteLine("Укажите сумму для снятия со счета:");
        
        decimal sum = Convert.ToDecimal(Console.ReadLine());
        Console.WriteLine("Введите id счета:");
        int id = Convert.ToInt32(Console.ReadLine());
        
        bank.Withdraw(sum, id);
    }
    private static void Put(Bank<Account> bank)
    {
        Console.WriteLine("Укажите сумму, чтобы снять со счета:");
       decimal sum = Convert.ToDecimal(Console.ReadLine());
        Console.WriteLine("Введите id счета:");
        int id = Convert.ToInt32(Console.ReadLine());
        
        bank.Put(sum, id); 
    }
    
    private static void CloseAccount(Bank<Account> bank)
    {
        Console.WriteLine("Введите id счета, который надо закрыть:");
        int id = Convert.ToInt32(Console.ReadLine());
        
        bank.Close(id);
    }
      // обработчики событий класса Account
        // обработчик открытия счета
    private static void OpenAccountHandler(object sender, AccountEventArgs e)
    {
        Console.WriteLine(e.Message);
    }
     // обработчик добавления денег на счет
    
    private static void AddSumHandler(object sender, AccountEventArgs e)
    {
        Console.WriteLine(e.Message);
    }
    
    // обработчик вывод средст
     private static void WithdrawSumHandler(object sender, AccountEventArgs e)
    {
        Console.WriteLine(e.Message);
         if(e.Sum>0)
             Console.WriteLine("Идем тратить деньги");
    }
     // обработчик вывод средст
     private static void CloseAccountHandler(object sender, AccountEventArgs e)
    {
        Console.WriteLine(e.Message);
        
    }
    }

// в директории BankLibrary
    public interface IAccount
    {
        void Put(decimal sum); // положить деньги на счёт
       decimal Withdraw(decimal sum); // снять деньги со счёта.
    }
    
    public delegate void AccountStateHandler (object sender, AccountEventArgs e); // делегат, для использования делегата необходима переменная делегата. 
    // делегат будет использоваться для создания событий. 
    // класс AccountEventArgs для обработки событий. 
    public class AccountEventArgs
    {
        public string Message {get; private set;} // сообщение
        public decimal Sum {get; private set;} // сумма,на которую изменился счёт. 
        
        
        public AccountEventArgs(string _mes, decimal _sum) // конструктор 
        {
           Message = _mes; 
            Sum = _sum;
        }
     
    }
    
    public abstract class Account : IAccount
    {
        
        protected internal event AccountStateHandler Withdrawed; //Событие, возникающее при выводе денег
        
        protected internal event AccountStateHandler Added; // Событие возникающее при добавление на счет
        
        protected internal event AccountStateHandler Opened; // Событие возникающее при открытии счета
        
        protected internal event AccountStateHandler Closed; // Событие возникающее при закрытии счета
       
        protected internal event AccountStateHandler Calculated;  // Событие возникающее при начислении процентов
 
        static int counter = 0;
        protected int _days = 0; // время с момента открытия счета
 
        public Account(decimal sum, int percentage)
        {
            Sum = sum;
            Percentage = percentage;
            Id = ++counter;
        }
 
        
        public decimal Sum { get; private set; } // Текущая сумма на счету
        
        public int Percentage { get; private set; } // Процент начислений
       
        public int Id { get; private set; }  // Уникальный идентификатор счета
       
        private void CallEvent(AccountEventArgs e, AccountStateHandler handler)  // вызов событий
        {
            if (e != null)
                handler?.Invoke(this, e);
        }
        // вызов отдельных событий. Для каждого события определяется свой витуальный метод
        protected virtual void OnOpened(AccountEventArgs e)
        {
            CallEvent(e, Opened);
        }
        protected virtual void OnWithdrawed(AccountEventArgs e)
        {
            CallEvent(e, Withdrawed);
        }
        protected virtual void OnAdded(AccountEventArgs e)
        {
            CallEvent(e, Added);
        }
        protected virtual void OnClosed(AccountEventArgs e)
        {
            CallEvent(e, Closed);
        }
        protected virtual void OnCalculated(AccountEventArgs e)
        {
            CallEvent(e, Calculated);
        }
 
        public virtual void Put(decimal sum)
        {
            Sum += sum;
            OnAdded(new AccountEventArgs("На счет поступило " + sum, sum));
        }
        // метод снятия со счета, возвращает сколько снято со счета
        public virtual decimal Withdraw(decimal sum)
        {
            decimal result = 0;
            if (Sum >= sum)
            {
                Sum -= sum;
                result = sum;
                OnWithdrawed(new AccountEventArgs($"Сумма {sum} снята со счета {Id}", sum));
            }
            else
            {
                OnWithdrawed(new AccountEventArgs($"Недостаточно денег на счете {Id}", 0));
            }
            return result;
        }
        // открытие счета
        protected internal virtual void Open()
        {
            OnOpened(new AccountEventArgs($"Открыт новый счет! Id счета: {Id}", Sum));
        }
        // закрытие счета
        protected internal virtual void Close()
        {
            OnClosed(new AccountEventArgs($"Счет {Id} закрыт.  Итоговая сумма: {Sum}", Sum));
        }
 
        protected internal void IncrementDays()
        {
            _days++;
        }
        // начисление процентов
        protected internal virtual void Calculate()
        {
            decimal increment = Sum * Percentage / 100;
            Sum = Sum + increment;
            OnCalculated(new AccountEventArgs($"Начислены проценты в размере: {increment}", increment));
        }
    }
    
    // добавление нового класса, представляющий
    // счёт до востребования.
    
    class DemandAccount: Account
    {
        public DemandAccount (decimal sum, int percentage): base (sum, percentage)
        {
            
        }
        
         protected internal virtual void Open()
        {
            base.OnOpened(new AccountEventArgs($"Открыт новый счет до востребования! Id счета: {this.Id}", this.Sum));
        }
            
    }
    
       class DepositAccount: Account
    {
        public DepositAccount (decimal sum, int percentage): base (sum, percentage)
        {
            
        }
        
         protected internal virtual void Open()
        {
            base.OnOpened(new AccountEventArgs($"Открыт новый депозитный счет! Id счета: {this.Id}", this.Sum));
        }
           
            public override void Put(decimal sum)
        {
                if(_days %30==0)
                    base.Put(sum);
                else
                    
                    base.OnAdded(new AccountEventArgs("На счет можно положить после 30-дневного срока ", 0));
   
        }
           
            public override decimal Withdraw(decimal sum)
        {
                if(_days%30==0)
                    return base.Withdraw(sum);
                else
                    base.OnWithdrawed(new AccountEventArgs($"Вывести средства можно только после 30-дневного периода", 0));
                return 0;
            }
           
           protected internal override void Calculate()
           {
                if(_days%30==0)
                    base.Calculate();
           }
           
           
            
    }
    
    public enum AccountType
    {
        Ordinary,
        Deposit
    }
    public class Bank <T> where T: Account
    {
        T [] accounts;
        public string Name {get; private set;}
        
        public Bank(string name)
        {
            this.Name = name;
        }
        
        //метод создания счета
        public void Open(AccountType accountType, decimal sum, 
        AccountStateHandler addSumHandler, AccountStateHandler withdrawSumHandler,
        AccountStateHandler calculationHandler, AccountStateHandler closeAccountHandler, 
        AccountStateHandler openAccountHandler)
        {
            T newAccount =null;
            switch(accountType)
            {
                case AccountType.Ordinary:
                newAccount = new DemandAccount(sum, 1 ) as T;
                break;
                
                case AccountType.Deposit:
                newAccount = new DepositAccount(sum, 40 ) as T;
                break;
            }
            
            if(newAccount==null)
                throw new Exception("Ошибка создания счета");
            
            // добавляем новый счет в массив счетов
            
            if(accounts==null)
                accounts = new T[] {newAccount};
            else
            {
                T[] tempAccounts= new T[accounts.Length+1];
                for(int i=0;i<accounts.Length;i++)
                    tempAccounts[i]=accounts[i];
                tempAccounts[tempAccounts.Length-1]=newAccount;
                accounts= tempAccounts;
            }
            
            //установка обработчика событий счета
            
            newAccount.Added+=addSumHandler;
             newAccount.Withdrawed+=withdrawSumHandler;
            newAccount.Closed+=closeAccountHandler;
            newAccount.Opened+=openAccountHandler;
            newAccount.Calculated+=calculationHandler;
            
            newAccount.Open();
        }
        
        //добавление средств на счет
            public void Put(decimal sum, int id)
        {
            T account = FindAccount(id);
                if(account ==null)
                throw new Exception ("Счёт не найден");
                account.Put(sum);
                
        }
        //вывод средств
        
        public void Withdraw(decimal sum,int id)
        {
            T account = FindAccount(id);
            if(account ==null)
                throw new Exception ("Счёт не найден");
                account.Withdraw(sum);
        }
        
        //закрытие счёт
        
        public void Close(int id)
        {
            int index;
             T account = FindAccount(id, out index);
            if(account ==null)
                throw new Exception ("Счёт не найден");
            
                account.Close();
            
            if(accounts.Length<=1)
                accounts=null;
            else
            {
               // уменьшаем массив счетов, удаляя из него закрытый счёт
                T[] tempAccounts = new T[accounts.Length-1];
                for(int i =0, j=0; i<accounts.Length;i++)
                {
                    if(i!=index)
                    tempAccounts[j++]=accounts[i];
                }
                 accounts=tempAccounts;
            }
           
        }
        //начисление процентов на счетам
        
        public void CalculatePercentage()
        {
            if(accounts==null)//если массив не создан, выходим из метода
                return;
            for(int i =0; i<accounts.Length;i++)
            {
                accounts[i].IncrementDays();
                accounts[i].Calculate();
            }
                
        }
        
        // поиск счета по id
        
        public T FindAccount(int id)
        {
            for(int i =0; i<accounts.Length;i++)
            {
                if(accounts[i].Id==id)
                    return accounts[i];
            }
            return null;
        }
        //перегруженная версия поиска счетов
        
        public T FindAccount(int id, out int index)
        {
           for(int i =0; i<accounts.Length;i++)
            {
                if(accounts[i].Id==id)
                {
                    index=i;
                    return accounts[i];
                }
            }
            index=-1;
            return null;
 
      }
      
   }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,31 sec, absolute running time: 0,13 sec, cpu time: 0,11 sec, average memory usage: 15 Mb, average nr of threads: 3, absolute service time: 0,47 sec