L'uso eccessivo dei delegati è una cosa negativa?

Buongiorno.

Mi è stato detto che una buona pratica per i metodi di scrittura è di rendere il metodo solo responsabile di fare una cosa. Per me aveva senso ora che lo guardavo indietro a posteriori. Ci sono un paio di motivi per cui mi piace codificare in questo modo - per me sono:

1. Il codice è gestibile
2. Il codice è più leggibile
3. Una migliore comprensione di ciò che il metodo fa è mantenuto

Ma ecco che arriva il problema che mi riguarda. A volte l'esecuzione di un'attività richiede più di 1 azione da eseguire. Un sacco di codice degli sviluppatori che guardo ogni giorno fa da 7 a 8 cose per metodo, dove potrebbe essere stato suddiviso e assegnato a un delegato per eseguire i metodi in sequenza.

Lavorando su progetti enormi, quali saranno le implicazioni dell'uso di molti delegati per eseguire i metodi in sequenza? Dovrei preoccuparmi di usare molti delegati nel mio codice?

Esempio -

private delegate void Factory();
    Factory factory = null;
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            factory += SetCatalogClientProxy;
            factory += SetHelper;
            factory += GetAccessToken;
            //factory += GetCatalog;
            factory += GetToken;
            factory.Invoke();
        }
        catch (Exception ex)
        {
            AddToResult(ex.Message + NEWLINE + ex.StackTrace.Replace(" at ", " at " + NEWLINE).Replace(" in ", " in " + NEWLINE));
        }
    }

    #region Test Process Methods

    private void SetCatalogClientProxy()
    {
        catalog = new JAM.CatalogClientProxy();
        AddToResult("CatalogClientProxy Successfully initialized");
    }

    private void SetHelper()
    {
        helper = new JAM.HelperClass();
        AddToResult("HelperClass Successfully Intialized");
    }

    private void GetAccessToken()
    {
        accessToken = JAM.CatalogClientProxy._accessToken;
        if (string.IsNullOrEmpty(accessToken))
        {
            catalog.GetACSClaim();
            accessToken = JAM.CatalogClientProxy._accessToken;
        }
        AddToResult("Accesstoken Retrieved." + NEWLINE + accessToken);
    }

    private void GetCatalog()
    {
        catalog.CallCatalogService("fullcatalog", utcTime, country, "2", false);
        AddToResult(helper.Catalog(baseUrl, utcTime, page, country, accessToken));
    }

    private void GetToken()
    {
        var Fulfillment = new JAM.FulfillmentServiceProxy(Guid.NewGuid().ToString());
        ClassImport.FulfillmentInfo result = Fulfillment.GetToken("ABC-11111", "123456", "ZA", "123456", "123456", JAM.CatalogClientProxy._accessToken);

        if (result != null)
        {
            var output = "Products" + NEWLINE;
            foreach (var p in result.Products)
            {
                output += "    " + p.ProductName + "<br/>";
                foreach (var l in p.Links)
                {
                    output += "        " + l.Uri + "<br/>";
                }
            }
            AddToResult(output);
        }
        else
        {
            AddToResult("No products Found");
        }
    }
    #endregion

    #region Logging To Page

    private void AddToResult(string text)
    {
        result.InnerHtml += String.Concat("<strong>[", DateTime.Now.ToString(), "]</strong> ", text, NEWLINE);
    }

    #endregion

Questo è da una delle mie pagine di test. C'è solo 1 delegato qui, ma su altri progetti su cui lavoro a volte ho 5 o 6 delegati impostati in modo simile per eseguire i metodi in sequenza, dove cerco di mantenere i metodi a 1 azione ciascuno.