Penso di avere una conoscenza decente di ciò che è il principio di Inversione di dipendenza (DIP), la mia confusione è più legata all'iniezione di dipendenza.
La mia comprensione è che l'intento di DI è disaccoppiare parti di un'applicazione, per consentire modifiche in una parte senza influenzarne un'altra, assumendo che l'interfaccia non cambi.
Per l'amor di esempi, abbiamo questo
public class MyClass(IMyInterface interface)
{
public MyClass
{
interface.DoSomething();
}
}
public interface IMyInterface
{
void DoSomething();
}
Come è questo
var iocContainer = new UnityContainer();
iocContainer.Resolve<MyClass>();
fare pratica migliore di fare questo
//if multiple implementations are possible, could use a factory here.
IMyInterface interface = new InterfaceImplementation();
var myClass = new MyClass(interface);
Può darsi che mi manchi un punto molto importante, ma non riesco a vedere cosa si guadagna. Sono consapevole del fatto che utilizzando un container IOC posso gestire facilmente un ciclo di vita degli oggetti, che è un +1, ma non credo che sia fondamentale per ciò che riguarda IOC.
Modifica
Ecco un esempio espanso:
void Main()
{
IRepository repository = new AddRepository();
var maths = new PointlessMaths(repository,5);
Console.WriteLine(maths.Result);
}
public interface IRepository
{
int DoSomething(int id);
}
public class AddRepository : IRepository
{
public int DoSomething(int id)
{
return id + 1;
}
}
public class SubtractRepository : IRepository
{
public int DoSomething(int id)
{
return id - 1;
}
}
public class PointlessMaths
{
public int Result {get;set;}
public PointlessMaths(IRepository repository, int id)
{
Result = repository.DoSomething(id);
}
}