Reputation: 473
According to this answer, I could inject the dependencies to the constructor. However, what if let's say I have 10 'sub-presenters'? Should I inject all those via the constructor? What's the recommended design pattern (factory method, facade, etc) to use for this situation? I appreciate if you can you give sample code to test it using using NUnit and NSubstitute? Thanks in advance!
public void PresenterMain(IViewMain view
, IServiceMain service
, IAddNewJobPresenter addNewJobPresenter
, IClientManagementPresenter clientManagementPresenter
, IJobBatchesPresenter jobBatchesPresenter
, IReportsPresenter reportPresenter...etc)
Upvotes: 0
Views: 240
Reputation: 56909
Given your consumer needs to use 10 instances of presenter, there are a couple options. Here is some basic framework to setup the scenario:
public interface IPresenter
{
void Present();
}
public interface IConsumer
{
void DoSomething();
}
public class SomeConsumer : IConsumer
{
private readonly IPresenter presenter;
public SomeConsumer(IPresenter presenter)
{
if (presenter == null)
throw new ArgumentNullException("presenter");
this.presenter = presenter;
}
public void DoSomething()
{
this.presenter.Present();
}
}
You could use the composite pattern, in which you could then order the presenters in a list.
public class Presenter1 : IPresenter
{
public void Present()
{
// Do something here
}
}
public class Presenter2 : IPresenter
{
public void Present()
{
// Do something here
}
}
public class Presenter3 : IPresenter
{
public void Present()
{
// Do something here
}
}
public class CompositePresenter : IPresenter
{
private readonly IPresenter[] presenters;
public CompositePresenter(IPresenter[] presenters)
{
if (presenters == null)
throw new ArgumentNullException("presenters");
this.presenters = presenters;
}
public void Present()
{
// Do nothing except delegate the call to the nested
// instances. You may need to do some extra work to deal
// with multiple return values, like add up the values
// or decide which value works best for the scenario.
foreach (var presenter in this.presenters)
{
presenter.Present();
}
}
}
And then wire it up like:
var presenter1 = new Presenter1();
var presenter2 = new Presenter2();
var presenter3 = new Presenter3();
var compositePresenter = new CompositePresenter(new IPresenter[] {
presenter1,
presenter2,
presenter3
});
var consumer = new SomeConsumer(compositePresenter);
Or you could use a decorator pattern:
public class Presenter1 : IPresenter
{
public Presenter1(IPresenter innerPresenter)
{
if (innerPresenter == null)
throw new ArgumentNullException("innerPresenter");
this.innerPresenter = innerPresenter;
}
public void Present()
{
// Do something here
// You could make this call conditional
this.innerPresenter.Present();
// Or do something here
}
}
public class Presenter2 : IPresenter
{
public Presenter2(IPresenter innerPresenter)
{
if (innerPresenter == null)
throw new ArgumentNullException("innerPresenter");
this.innerPresenter = innerPresenter;
}
public void Present()
{
// Do something here
// You could make this call conditional
this.innerPresenter.Present();
// Or do something here
}
}
public class Presenter3 : IPresenter
{
public Presenter3(IPresenter innerPresenter)
{
if (innerPresenter == null)
throw new ArgumentNullException("innerPresenter");
this.innerPresenter = innerPresenter;
}
public void Present()
{
// Do something here
// You could make this call conditional
this.innerPresenter.Present();
// Or do something here
}
}
public class NullPresenter : IPresenter
{
public void Present()
{
// Do nothing here - this class is a placeholder
// in case you want to expand the design later
}
}
And then wire it up like:
var nullPresenter = new NullPresenter();
var presenter3 = new Presenter3(nullPresenter);
var presenter2 = new Presenter2(presenter3);
var presenter1 = new Presenter1(presenter2);
var consumer = new SomeConsumer(presenter1);
Upvotes: 1