De multe ori, ca sa intelegi un cod pe care il “mostenesti” sau il preiei dintr-o aplicatie, ajungi sa faci ceea ce se cheama refactoring. Ca o scurta definitie, refactoring-ul reprezinta o restructurare ce nu va schimba comportamentul software-ului, in mod vizibil. El inseamna o “curatare” a codului intr-o maniera eficienta si organizata, o serie de schimbari care va ajuta la o mai buna intelegere a codului si la identificarea unor bug-uri nedescoperite.

Una din cele mai intalnite probleme este atunci cand corpul unei metode este foarte lung, logica acesteia contine mai multe unitati, calcule, etc.
Personal, prefer ca metodele pe care le scriu sa fie scurte. Nu exista un minim sau un maxim al numarului de linii de cod. Alegerea unui nume bun este un alt lucru important. O metoda cu un nume bun nici nu are nevoie de comentariu. Cel mai important este ca numele metodei si codul continut sa fie in cea mai stransa legatura posibila. Sunt convins ca in nenumarate situatii, in interiorul unei metode, cand parcurgem cod, gasim linii care au nevoie de comentarii, care nu prezinta scopul metodei. Aceasta este o situatia cand se recomanda mutarea acestor linii intr-o metoda proprie. Actiunea reprezinta o metoda de refactoring si se numeste Extract Method. De exemplu:

    class Agent
    {
        /// <summary>
        /// Numele agentului
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Salariu pe zi
        /// </summary>
        public decimal WagePerDay { get; set; }

        /// <summary>
        /// Numarul de zile lucrate
        /// </summary>
        public int WorkedDays { get; set; }

        /// <summary>
        /// Bonus
        /// </summary>
        public decimal Bonus { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Agent a = new Agent { Name = "Marius", WagePerDay = 30, WorkedDays = 20, Bonus = 100};

            DisplayAgentInfo(a);
        }

        /// <summary>
        /// Afiseaza informatii despre un agent
        /// </summary>
        /// <param name="a"></param>
        static void DisplayAgentInfo(Agent a)
        { 
            Console.WriteLine("Numele agentului: {0}", a.Name);
            Console.WriteLine("Salariu/zi: {0}", a.WagePerDay);
            Console.WriteLine("Zile lucrate:{0}", a.WorkedDays);
            Console.WriteLine("Bonus:{0}", a.Bonus);

            //calculeaza salariu
            var salary = a.WagePerDay * a.WorkedDays + a.Bonus;
           
            Console.WriteLine("Salariul este {0}", salary);

            Console.ReadLine();
        }
    }

Se observa calculul salariului in interiorul metodei responsabile cu afisarea informatiilor despre un agent. Aceasta linie de cod poate fi mutata intr-o metoda al carei scop sa fie doar calculul salariului. Astfel, metoda poate fi apelata in mai multe locuri, iar modificarea formulei de calcul se poate face intr-un singur loc.

Cream o noua metoda, numele acesteia trebuie sa defineasca exact intentia, exact ceea ce urmeaza sa faca metoda. Copiem codul din metoda sursa in noua metoda.

        static decimal CalculateSalary(decimal wage, decimal days, decimal bonus)
        {
            return wage * days + bonus;
        }

In locul codului extras, apelam metoda nou creata. Urmeaza compilarea si testarea.

        /// <summary>
        /// Afiseaza informatii despre un agent
        /// </summary>
        /// <param name="a"></param>
        static void DisplayAgentInfo(Agent a)
        { 
            Console.WriteLine("Numele agentului: {0}", a.Name);
            Console.WriteLine("Salariu/zi: {0}", a.WagePerDay);
            Console.WriteLine("Zile lucrate:{0}", a.WorkedDays);
            Console.WriteLine("Bonus:{0}", a.Bonus);

            var salary = CalculateSalary(a.WagePerDay, a.WorkedDays, a.Bonus);
           
            Console.WriteLine("Salariul este {0}", salary);

            Console.ReadLine();
        }

Desigur, nu trebuie exagerat cu Extract Method. In cazul in care nu se gaseste un nume sugestiv pentru noua metoda, liniile de cod vizate pentru a fi extrase pot fi lasate in continuare in corpul metodei vechi.
In cel mai simplu mod, Extract Method consta in mutarea unei parti din codul unei metode intr-o noua metoda, fara a afecta functionalitatea. In Visual Studio, la click dreapta pe selectia unor linii de cod, exista optiunea Extract Method….