Stile di programmazione modulare e riutilizzabile

[gik25]

Ho preso un esempio da CodeProject e mi sono accorto che il codice è fortemente cablato e impossibile da riutilizzare. Dovendo riscriverlo ne approfitto per far condividere quelli che secondo me sono i vantaggi di uno stile corretto di programmazione.

Questo è il codice come veniva presentato dall'esempio

private void button1_Click(object sender, EventArgs e)
        {
            if (textBox1.Text == "")
            {
                MessageBox.Show("You have not typed the URL", "URL Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {

                string URL = textBox1.Text;
                string filetype = URL.Substring(URL.LastIndexOf(".") + 1, (URL.Length - URL.LastIndexOf(".") - 1));
                filetypevalue.Text = filetype.ToUpper();
                string filename = URL.Substring(URL.LastIndexOf("/") + 1, (URL.Length - URL.LastIndexOf("/") - 1));
                namelabel.Text = filename;

                System.Net.WebRequest req = System.Net.HttpWebRequest.Create(textBox1.Text);
                req.Method = "HEAD";
                System.Net.WebResponse resp = req.GetResponse();
                long ContentLength = 0;
                long result;
                if (long.TryParse(resp.Headers.Get("Content-Length"), out ContentLength))
                {
                    string File_Size;


                    if (ContentLength >= 1073741824)
                    {
                        result = ContentLength / 1073741824;
                        kbmbgb.Text = "GB";
                    }
                    else if (ContentLength >= 1048576)
                    {
                        result = ContentLength / 1048576;
                        kbmbgb.Text = "MB";
                    }
                    else
                    {
                        result = ContentLength / 1024;
                        kbmbgb.Text = "KB";
                    }
                    File_Size = result.ToString("0.00");
                    sizevaluelabel.Text = File_Size;
                }
            } 
        } 

E questo è come penso debba essere strutturato un codice per essere riusato:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (textBox1.Text.Trim() == "")
            {
                MessageBox.Show("You have not typed the URL", "URL Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                //aggiorno la grafica della form da una classe esterna in modo da limitare le dimensioni in numero di metodi della classe corrente
                FormHelper.AggiornaGrafica_SettaNomeETipoFile(this);

                long ContentLength = WebUtiliy.GetContentLength(textBox1.Text);

                //aggiorno la grafica della form da una classe esterna in modo da limitare le dimensioni in numero di metodi della classe corrente
                FormHelper.AggiornaGrafica_SettaDimensioniFile(this, ContentLength);
            }
        }
    }

    public static class WebUtiliy
    {
        /// <summary>
        /// Restituisce la dimensione in byte di un oggetto presente ad un determinato url
        /// </summary>
        public static long GetContentLength(string url)
        {
            WebRequest req = HttpWebRequest.Create(url);
            req.Method = "HEAD";
            WebResponse webResponse = req.GetResponse();

            //Calcola la dimensione del file via web
            return GetContentLength(webResponse);
        }

        /// <summary>
        /// Restituisce la dimensione in byte di un oggetto WebResponse
        /// </summary>
        public static long GetContentLength(WebResponse webResponse)
        {
            long ContentLength = 0;
            long.TryParse(webResponse.Headers.Get("Content-Length"), out ContentLength);
            return ContentLength;
        }

        /// <summary>
        /// Metodo che converte un intero rappresentante una dimensione in Byte nella sua rappresentazione stringa in KB/MB/GB
        /// </summary>
        public static long ConvertByteDimensionToString(long ContentLength, out string unitaDiMisura)
        {
            long result;

            if (ContentLength >= 1073741824)
            {
                result = ContentLength / 1073741824;
                unitaDiMisura = "GB";
            }
            else if (ContentLength >= 1048576)
            {
                result = ContentLength / 1048576;
                unitaDiMisura = "MB";
            }
            else
            {
                result = ContentLength / 1024;
                unitaDiMisura = "KB";
            }

            return result;
        }
    }



    /// <summary>
    /// Classe utilizzata per raggruppare i metodi che modificano l'interfaccia grafica della form
    /// </summary>
    public static class FormHelper
    {
        public static void AggiornaGrafica_SettaDimensioniFile(Form1 form1, long ContentLength)
        {
            string unitaDiMisura;
            string File_Size = WebUtiliy.ConvertByteDimensionToString(ContentLength, out unitaDiMisura).ToString("0.00");
            form1.kbmbgb.Text = unitaDiMisura;
            form1.sizevaluelabel.Text = File_Size;
        }

        public static void AggiornaGrafica_SettaNomeETipoFile(Form1 form1)
        {
            string URL = form1.textBox1.Text;
            string filetype = URL.Substring(URL.LastIndexOf(".") + 1, (URL.Length - URL.LastIndexOf(".") - 1));
            string filename = URL.Substring(URL.LastIndexOf("/") + 1, (URL.Length - URL.LastIndexOf("/") - 1));
            form1.filetypevalue.Text = filetype.ToUpper();
            form1.namelabel.Text = filename;
        }
    } 

[gik25]

Sicuramente è meno intuitivo, a prima vista bisogna andare a capire cosa fa. Qualcuno potrebbe obiettare che sia anche meno efficiente ma in realtà i metodi vengono "inlined" dal compilatore. Quindi non ci sono differenze di performance.

Il punto è che quando il codice è nella seconda forma si ha a disposizione una libreria riutilizzabile da tutti in un secondo. Un codice totalmente disaccoppiato diviso in parecchi moduli, che non necessiterà mai e poi mai di copiare e incollare codice per replicare le stesse funzionalità.

Un metodo GetContentLength in overload che permette di creare ulteriori migliorie, senza replicare codice. Ad esempio se si dovesse utilizzare un Proxy.

Questo è solo l'inizio ed è molto artigianale. Si poteva usare un framework, separare nettamente i contenuti dalla presentazione. Però la realtà è che se il proggetto cresce, se dobbiamo riusare e condividere funzionalità tenere presenti aspetti di ingegneria del software contribuisce ai nostri interessi.

[gik25]

Vista la mia ignoranza e inesperienza, vi affido in mani più serie:
http://sourcemaking.com/refactoring

Questo sito analizza i vantaggi del refactoring e dell'utilizzo dei pattern.