How To: Create a multy Layer Method

Giusto per mettere qualche puntino sulle I anche se i per questa volta non è il prefisso di interfaccia.

In molti casi, a volte in troppi, non è difficile imbattersi in codice scritto davvero male. Le cause, sono sempre le stesse ma riassumibili in un unica parola "premura".

Vi posto un esempio banale banale di come scrivere due righette di codice fatte bene, e di contro leggibili .

Come sempre si tratta di un esempio ben poco edificante, ma quanto meno chiaro.

Si tratta di un metodo spalmato su più livelli, e con questo che cosa si intende? che fra il chiamante e il reale esecutore del metodo c'e' almeno un secondo attore.

Questa situazione consente molteplici considerazione e attività ma non è questo il post in cui parlarne.

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

namespace TestLayer
{
    class Program
    {
        static void Main(string[] args)
        {
            EntryPoint ep = new EntryPoint();

            Console.WriteLine(ep.GetData("demo"));

            Console.ReadLine();
        }
    }

    class EntryPoint
    {
        EntryPointLogger epl = new EntryPointLogger();
        EntryPointRealMethod eprm = new EntryPointRealMethod();

        public string GetData(string inputValue)
        {
            string outputValue = "";
            try
            {
                epl.DoWriteLog("Open", 1);
                epl.DoWriteLog("Execute start", 2);
                eprm.GetData(inputValue);
                epl.DoWriteLog("Execute end", 2);
            }
            catch (Exception ex)
            {
                epl.DoWriteLog("Error", 2);
                epl.DoWriteLog("ex:" + ex.Message.ToString(), 2);
            }
            finally
            {
                epl.DoWriteLog("Close", 1);
                eprm = null;
            }
            return outputValue;
        }
    }

    class EntryPointRealMethod
    {
        public string GetData(string value)
        {
            if (value == "HelloWord")
            {
                return "nice try";
            }
            return "*" + value + "*";
        }
    }

    class EntryPointLogger
    {
        public void DoWriteLog(string message, int level)
        {
            if (level == 1)
            {
                Console.WriteLine("Trace:" + message);
                return;
            }
            if (level == 2)
            {
                Console.WriteLine("External:" + message);
                return;
            }
            Console.WriteLine("Error:" + message);
        }
    }

Non è difficile notare che tutta la tracciatura dell'errore e in un unico punto e tutto quello che avverà nel sottostante sarà gestito esclusivamente in quell'unico punto.

In più sfruttando un salto posso cambiare la logica di RealMethod senza cambiare il resto, in più se ho fatto le cose "per bene" posso loggare sempre in un solo punto ...

Tanti vantaggi come un codice leggibile, un codice manutenibile...