Банковские счета

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApp34
{
    public enum Operation
    {
        DEPOSIT,
        WITHDRAW,
        BALANCE,
        TRANSFER,
        INCOME
    }
 
    public static class Clients
    {
        static readonly Dictionary<string, int> clients = new Dictionary<string, int>();
 
        static readonly Func<string, string> NormalizeName = x => x.ToUpperInvariant();
 
        public static void Deposit(string name, int sum, bool checkName = true)
        {
            if (checkName) name = NormalizeName(name);
            if (checkName && !clients.ContainsKey(name)) clients.Add(name, 0);
 
            int result, init = clients[name];
            do
            {
                result = clients[name];
                clients[name] += sum;
            } while (init != Interlocked.CompareExchange(ref result, clients[name], init));
        }
 
        public static void Withdraw(string name, int sum)
        {
            name = NormalizeName(name);
 
            if (!clients.ContainsKey(name)) clients.Add(name, 0);
 
            int total, init = clients[name];
            do
            {
                total = clients[name];
                clients[name] -= sum;
            } while (init != Interlocked.CompareExchange(ref total, clients[name], init));
        }
 
        public static void Transfer(string nameFrom, string nameTo, int sum)
        {
            nameFrom = NormalizeName(nameFrom);
            nameTo = NormalizeName(nameTo);
 
            if (!clients.ContainsKey(nameFrom)) clients.Add(nameFrom, 0);
            if (!clients.ContainsKey(nameTo)) clients.Add(nameTo, 0);
 
            lock (clients)
            {
                clients[nameFrom] -= sum;
                clients[nameTo] += sum;
            }
        }
 
        public static void Income(decimal percent)
        {
            Parallel.ForEach(clients.Where(x => x.Value > 0), client =>
            {
                Deposit(client.Key, (int)(client.Value * (percent / 100M)), false);
            });
        }
 
        public static string Balance(string name)
        {
            name = NormalizeName(name);
 
            if (clients.ContainsKey(name)) return clients[name].ToString();
 
            return "ERROR";
        }
    }
 
    class Program
    {
        static Dictionary<string, Operation> Alias => new Dictionary<string, Operation>()
        {
            { "DEPOSIT", Operation.DEPOSIT },
            { "WITHDRAW", Operation.WITHDRAW },
            { "BALANCE", Operation.BALANCE },
            { "TRANSFER", Operation.TRANSFER },
            { "INCOME", Operation.INCOME },
        };
 
        static Dictionary<Operation, Delegate> Actions => new Dictionary<Operation, Delegate>()
        {
            { Operation.DEPOSIT, Deposit },
            { Operation.WITHDRAW, Withdraw },
            { Operation.BALANCE, Balance },
            { Operation.TRANSFER, Transfer },
            { Operation.INCOME, Income },
        };
 
        static readonly Action<string, int> Deposit = (x, y) => Clients.Deposit(x, y);
        static readonly Action<string, int> Withdraw = (x, y) => Clients.Withdraw(x, y);
        static readonly Action<string> Balance = x => Console.WriteLine(Clients.Balance(x));
        static readonly Action<string, string, int> Transfer = (x, y, z) => Clients.Transfer(x, y, z);
        static readonly Action<decimal> Income = x => Clients.Income(x);
 
        static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
 
            Console.WriteLine("Готов к работе.");
            Console.WriteLine(new string('=', 24));
            Console.WriteLine();
 
            while (true)
            {
                var line = Console.ReadLine();
 
                var source = line.Split(' ');
 
                if (source.Length < 2) { Console.WriteLine("Ошибка ввода."); continue; };
 
                var operation = source[0].ToUpperInvariant();
 
                if (!Alias.ContainsKey(operation)){ Console.WriteLine("Ошибка. Неизвестная операция."); continue; };
 
                switch(Alias[operation])
                {
                    case Operation.DEPOSIT:
                    case Operation.WITHDRAW:
                        if (source.Length < 3) { Console.WriteLine("Ошибка ввода."); continue; };
                        if (!int.TryParse(source[2], out int sum)) { Console.WriteLine("Ошибка ввода."); continue; };
 
                        Actions[Alias[operation]].DynamicInvoke(source[1], sum);
                        break;
 
                    case Operation.BALANCE:
                        Actions[Operation.BALANCE].DynamicInvoke(source[1]);
                        break;
 
                    case Operation.INCOME:
                        if (!decimal.TryParse(source[1], out decimal sumIncome)) { Console.WriteLine("Ошибка ввода."); continue; };
 
                        Actions[Operation.INCOME].DynamicInvoke(sumIncome);
                        break;
 
                    case Operation.TRANSFER:
                        if (source.Length < 4) { Console.WriteLine("Ошибка ввода."); continue; };
                        if (!int.TryParse(source[3], out int sumTransfer)) { Console.WriteLine("Ошибка ввода."); continue; };
 
                        Actions[Operation.TRANSFER].DynamicInvoke(source[1], source[2], sumTransfer);
                        break;
                }
            }
        }
    }
}