Co sądzicie o używaniu pustych interfejsów? Wiem, że jest to częsta praktyka ale czy dobra? Narusza jakieś zasady dobrego kodu? A może jakieś inne?
Weźmy pod uwagę takie przypadki:
- W tym przypadku puste interfejsy pokazują nam programistą z jakim typem będziemy mieli do czynienia.
interface IDao { X Get(); }
interface IADao : IDao { }
interface IBDao : IDao { }
class ADao : IADao { X Get() { ... } }
class BDao : IBDao { X Get() { ... } }
// IoC config
Bind<IADao>().To<ADao>();
Bind<IBDao>().To<BDao>();
ctor(IADao aDao) { ... }
ctor(IBDao bDao) { ... }
Proste? widzimy jaki typ wstrzykujemy. Np. ICommentsDao czy IEntriesDao.
- Generyki
interface IDao<T> { T Get(); }
interface IADao : IDao<A> { }
interface IBDao : IDao<B> { }
class ADao : IADao { X Get() { ... } }
class BDao : IBDao { X Get() { ... } }
// IoC config
Bind<IADao>().To<ADao>();
Bind<IBDao>().To<BDao>();
ctor(IADao aDao) { ... }
ctor(IBDao bDao) { ... }
Ukrywamy implementacje?
interface IDao { X Get(); }
class ADao : IDao { X Get() { ... } }
class BDao : IDao { X Get() { ... } }
// IoC config
Bind<IDao>().To<ADao>().Named("ADao");
Bind<IBDao>().To<BDao>().Named("BDao");
ctor(["ADao"] IDao aDao) { ... }
ctor(["BDao"] IDao bDao) { ... }
W tym przypadku nie ma pustych interfejsów ale rozróżnić można za pomocą argumenty/modyfikatora czy czegoś innego.
Jak uważacie? Jak stosujecie?