Condividi le istanze di servizio tra tutti i controller?

Abbiamo acquisito la codifica su un progetto .NET MVC e, poiché sono relativamente inesperto con molti degli approcci di progettazione MVC, sto lavorando per ottenere una buona comprensione delle scelte di progettazione.

Un aspetto che ha attirato la mia attenzione è che ogni classe di controller è inizializzata usando istanze di servizi esistenti. Nel mio passato non MVC, di solito avvio un servizio proprio quando ne ho bisogno, o al massimo ho un'istanza di servizio per quell'istanza del controller.

Per mostrare esattamente cosa intendo:

namespace Project.Controllers
{
    public class AccountController : BaseController
    {
        private readonly IAccountService _iAccountService;
        private readonly ISettingsService _iSettingService;
        private readonly IGenericContentService _genericContentService;
        private readonly IMemberService _memberService;

        public AccountController(IAccountService iAccountService, ISettingsService iSettingService, IGenericContentService genericContentService, IMemberService memberService)
        {
            _iAccountService = iAccountService;
            _iSettingService = iSettingService;
            _genericContentService = genericContentService;
            _memberService = memberService;
        }
    }
}

Penso che il codice sottostante stia causando l'avvio dei controller con i servizi richiesti:

namespace Project.Framework.Bootstrappers
{
    public class MyApplicationRegistry : Registry
    {
        public MyApplicationRegistry()
        {
            Scan(assemblyScanner =>
             {
                 assemblyScanner.TheCallingAssembly();
                 assemblyScanner.WithDefaultConventions();
             });

            For<HttpContextBase>().Use(() => new HttpContextWrapper(HttpContext.Current));
            For<MembershipProvider>().Use(Membership.Provider);
        }
    }
}

La mia ipotesi è che questo migliori le prestazioni, poiché non hai bisogno di una nuova istanza di una classe di servizio ogni volta che ne hai bisogno, o anche per ogni controller.

Ma questo design rende il codice un po 'più ingombrante. La modifica di un metodo di servizio richiede di mantenere sia l'interfaccia sia la classe sincronizzati, il che rende solo un po 'più "overhead" per ogni cambio di codice.

Ci sono altre due opzioni che vedo:

1. Crea un'istanza per ciascun servizio per ciascun controller. Posso vedere come questo potrebbe diventare un problema per un'applicazione molto utilizzata, ma fino ad allora non vedo come si tratti di un problema.
2. Rendi tutti i metodi di servizio static in modo che non sia necessario creare un'istanza della classe. A me sembra che siano già così tanto. Quindi, nella mia mente, questa sembra una buona alternativa. Ma sospetto un generale disgusto per i metodi static in questi giorni per motivi che sto ancora imparando.

Quindi, come si confrontano queste opzioni? Mi manca qualcosa, e perché il modello di codice sopra sembra essere abbastanza popolare per .NET MVC?

Sembra che questo sia Iniezione delle dipendenze

Ho fatto un po 'più di lettura, e vedo che questo design è per l'iniezione delle dipendenze e utilizza la libreria StructureMap. I pregi del codice efficiente e disaccoppiato sono piuttosto convincenti, quindi sembra che il codice che ho mostrato sia migliore delle mie due opzioni, principalmente dal punto di vista del design ma anche dal punto di vista delle prestazioni.