Resolving Dependency by user parameter - c#-4.0

Question

I often need to use some class which itself have to load some dependency to work.
However, my component can have more than one concrete dependency implementation and it will choose one, rather than another one on some object parameter basis.
The real problem is that the object parameter is always unknown when application start up, so I'm not able in this moment to register any dependency, neither to resolve them.
Instead, for instance, when I need to use some class which itself needs to load some dependency I know the object parameter used by concreteBuilder in order to return me the appropriate implementation:
interface ISample { }
class ParamForBuildSomeISampleImplementation
{
// this instance cannot be create by my startUpApplication - Container - Resolver.
// Instead, all time dependency is required (buttonClick, pageLoad and so on), this class can be instantiated.
}
class Sample1 : ISample
{
// some implementation
}
class Sample2 : ISample
{
// some other implementation
}
class MyISampleFactory
{
// Build ISample
public ISample Build(ParamForBuilderISample obj)
{
// if obj.someProperty == ".." return new Sample1();
// else if obj.someProperty == "--" return new Sample2();
// else if ...
}
}
class NeedsDependency
{
ISample _someSample;
public NeedsDependency(ISample someSample)
{
_someSample = someSample;
}
}
// *** Controllor - ApplicationStartup - other ***
// Here I have not idea how to build ISample dependency
## EDIT
// *** button click event handler ***
// Ok, here I know how to create ParamForBuilderISample,
// hence I can call MyISampleFactory, then, I can Use NeedDependency class:
ParamForBuilderISample obj = new ...
obj.SomeProperty = ...
obj.otherSomeProperty = ...
ISample sample = MyISampleFactory.Build(obj);
NeedDependency nd = new NeedDependency(sample);
// perfect, now my buttonClick can execute all what it wants
nd.DoSomething();
nd.DoOtherStuff();
Is my scenario suitable to Dependency Injection pattern? If true, I really have not idea how build my pattern.

Answer 1

Instead of using constructor injection for passing in this 'runtime dependency', you might be better of using method injection. This might even completely remove the need for having a factory:
private readonly ISample sample;
public MyController(ISample sample) {
this.sample = sample;
}
public string button_click_event_handler(object s, EventArgs e) {
ParamForBuilderISample obj = new ...
obj.SomeProperty = ...
obj.otherSomeProperty = ...
this.sample.DoSomething(obj);
}
You still need to switch somewhere, but instead of having a factory, you could implement a proxy for ISample:
public class SampleProxy : ISample
{
private readonly Sample1 sample1;
private readonly Sample2 sample2;
public SampleProxy(Sample1 sample1, Sample2 sample2) {
this.sample1 = sample1;
this.sample2 = sample2;
}
public void DoSomething(ParamForBuilderISample param) {
this.GetSampleFor(param).DoSomething(param);
}
private ISample GetSampleFor(ParamForBuilderISample param) {
// if obj.someProperty == ".." return this.sample1;
// else if obj.someProperty == "--" return this.sample2;
// else if ...
}
}
Your ParamForBuilderISample looks like a parameter object. Dependency injection doesn't remove the need to have method arguments. Data should still be passed on through methods.