Single Responsibility delivers more dependencies, how fix this

Question

I have an MVC controller holding several abstractions (components). I want to reduce the amount of params to max 4 params.

To do this, I have several strategies that do not satisfy:

• Bundling a set of params into a new class where the params will be properties: that just masks the complexity.
• Resolve dependencies not by constructor injection but resolve by using factories: that also masks complexity.

Is there a better alternative approach ?

This the code of the controller:

public abstract class BaseVerificatieController : ExtendedController
    {
        private readonly IReferentieTabellenSysteemSettings referentieTabellenSysteemSettings;
        private readonly IProcessManager processManager;
        private readonly INavigationManager navigationManager;
        private readonly ITransactionFacade transactionFacade;
        private readonly IUISupportFacade uiSupportFacade;
        private readonly ProcessIndex process;

        protected BaseVerificatieController(
            IBackHandler backHandler,
            IReferentieTabellenSysteemSettings referentieTabellenSysteemSettings,
            IProcessManager processManager,
            INavigationManager navigationManager,
            ITransactionFacade transactionFacade,
            IUISupportFacade uiSupportFacade,
            ProcessIndex process)
            : base(backHandler)
        {
            this.referentieTabellenSysteemSettings = referentieTabellenSysteemSettings;
            this.processManager = processManager;
            this.navigationManager = navigationManager;
            this.transactionFacade = transactionFacade;
            this.uiSupportFacade = uiSupportFacade;
            this.process = process;
        }

        [HttpGet]
        public ActionResult Index()
        {
            var processStep = processManager.StartProcess(process);

            return navigationManager.RedirectFromProcessStep(process, processStep);
        }

        [HttpGet]
        public ActionResult Oe()
        {
            var model = new OeViewModel();

            var transactionResult = transactionFacade.VerifyIdentityStart();

            model.SetTransactionResult(transactionResult);

            return View(model);
        }

        [HttpPost]
        public ActionResult Oe(OeViewModel viewModel)
        {
            if (viewModel == null)
            {
                throw new ArgumentNullException("viewModel");
            }

            var transactionResult = transactionFacade.VerifyIdentityCheckRegisters(viewModel.SKN, null);

            if (transactionResult.MoveToStep != Business.Models.ProcessStepIndex.NoStep)
            {
                return navigationManager.RedirectFromTransactionResult(process, transactionResult);
            }

            var model = new OeViewModel();

            model.SetTransactionResult(transactionResult);

            return View(model);
        }

        [HttpGet]
        public ActionResult Oz()
        {
            var model = new OzViewModel(uiSupportFacade, referentieTabellenSysteemSettings);

            var idStaatResult = transactionFacade.IdStaatStart();

            model.SetIdStaatResult(idStaatResult);

            return View("Oz_SKDB", model);
        }

        [HttpPost]
        public ActionResult Oz(OzViewModel viewModel)
        {
            return RedirectToAction("Index", "Home");
        }

Answer 1

As @Maarten says in comments, I would get rid of the injection of the process and inject it where its needed (not passing it around).

I would further move all the view model logic into "view model handlers" and use a mediator for executing the view model handlers.

The dependencies such as the transactionFacade and uiSupportFacade would then be injected in the view model handlers. This can be achieved with the following:

 /// <summary>
/// Specifices that the target class is a view model. This is a marker interface and has no methods.
/// </summary>
public interface IViewModel
{
    // Marker interface
}

/// <summary>
/// Handles the <typeparamref name="TViewModel"/>.
/// </summary>
/// <typeparam name="TViewModel">The view model which should be handled.</typeparam>
public interface IHandleViewModel<out TViewModel> where TViewModel : IViewModel
{
    /// <summary>
    /// Creates a <typeparamref name="TViewModel"/>.
    /// </summary>
    /// <returns>An instance of the <typeparamref name="TViewModel"/>.</returns>
    TViewModel Handle();
}

/// <summary>
/// Handles the <typeparamref name="TViewModel"/> with the argument of <typeparamref name="TInput"/>
/// </summary>
/// <typeparam name="TInput">The argument for the view model</typeparam>
/// <typeparam name="TViewModel">The view model which should be handled.</typeparam>
public interface IHandleViewModel<out TViewModel, in TInput> where TViewModel : IViewModel
{
    /// <summary>
    /// Creates a <typeparamref name="TViewModel"/>.
    /// </summary>
    /// <returns>An instance of the <typeparamref name="TViewModel"/>.</returns>
    TViewModel Handle(TInput input);
}

/// <summary>
/// Processes and creates view models.
/// </summary>
public interface IProcessViewModels
{
    /// <summary>
    /// Creates the <typeparamref name="TViewModel"/>.
    /// </summary>
    /// <returns>The view model</returns>
    TViewModel Create<TViewModel>() where TViewModel : IViewModel;

    /// <summary>
    /// Create the <typeparamref name="TViewModel"/> with an argument of type <typeparamref name="TInput"/> 
    /// </summary>
    /// <typeparam name="TViewModel">The view model which should be constructed</typeparam>
    /// <typeparam name="TInput">The type of argument for the view model</typeparam>
    /// <param name="input">The argument for the view model</param>
    /// <returns>The view model</returns>
    TViewModel Create<TViewModel, TInput>(TInput input) where TViewModel : IViewModel;
}

This means you can inject a single IProcessViewModels into your controller and execute the handlers. E.g. by filling the dependency container (here Simple Injector):

/// <summary>
/// Registers the view models in the Simple Injector container
/// </summary>
/// <param name="container">The Simple Injector container</param>
/// <param name="viewModelAssemblies">The assembly location of the view models</param>
public static void RegisterViewModels(this Container container, Assembly[] viewModelAssemblies)
{
    if (container == null)
        throw new ArgumentNullException("container");

    if (viewModelAssemblies == null) 
        throw new ArgumentNullException("viewModelAssemblies");

    container.RegisterSingle<IProcessViewModels, ViewModelProcessor>();
    container.RegisterManyForOpenGeneric(typeof(IHandleViewModel<>), viewModelAssemblies);
    container.RegisterManyForOpenGeneric(typeof(IHandleViewModel<,>), viewModelAssemblies);
}

The above code is from my "Nerve Framework" here: https://github.com/janhartmann/nerve-framework/tree/master/NerveFramework.Web.Mvc