Marker interfaces - dobre czy złe

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:

1. 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.

2. 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?

Staram się unikać, ale czasami nie ma wyjścia. Np. w sytuacji, gdy mamy kompletnie niezwiązane ze sobą dane, a w pewnym miejscu chcę je potraktować w jakiś określony sposób.
Ale robienie tego dla jakichś DAO czy serwisów, to nie bardzo mogę w tym znaleźć jakikolwiek sens. Zwłaszcza we wrappowaniu generycznego interfejsu w niegeneryczny.

Jak robisz coś, po refleksjach to się przydaje jako marker zamiast atrybutów.

Czyli takie użycie jak przedstawiłem jest bez sensu ponieważ nie wnosi nic nowego a jedynie zaciemnia kod? :)

Mogę prosić o kawałek kodu, o którym mówicie, że wtedy nie ma wyjścia? Albo się przydaje?

Bogaty Kot napisał(a):

Mogę prosić o kawałek kodu, o którym mówicie, że wtedy nie ma wyjścia? Albo się przydaje?

Mam dwa rodzaje eventów w systemie: domenowe i integracyjne. Różnica między nimi jest zasadniczo taka, że domenowe są "in process" a integracyjne lecą już po zapisie stanu. Zależnie od rodzaju obiekty eventów implementują odpowiednie interfejsy, a te wyglądają tak:

interface IDomainEvent { }

interface IIntegrationEvent { }

Może się zdarzyć, że w przyszłości te interfejsy będą rozszerzone o np. 'Id' czy coś w tym stylu, ale na dzień dzisiejszy są puste.