public interface IFarter
{
  bool DoFart();
 
  event EventHandler<ShitFlowingOnMyLegEventArgs> ShitFlowingInMyLeg;
}
 
public class ShitFlowingOnMyLegEventArgs : EventArgs
{
  public ShitFlowingOnMyLegEventArgs(bool leftLeg, double ammountInKilogramms)
  {
    this.LeftLeg = leftLEg;
    this.AmmountInKilogramms = ammountInKilogramms;
  }
 
  public bool LeftLeg { get; private set; }
 
  public double AmmountInKilogramms { get; private set; }
}

A DoFart metódussal meg lehet kérni a delikvenst, hogy ugyan, fingjon már egyet. Ha tud, akkor megereszt egy komolyabb lepkét, és visszatér ‘true’-val, ha nem, akkor csak elvörösödik a feje, bef0s1k, erről egy eseménykezelőn keresztül tájékoztatja a külvilágot, és a visszatérési érték ‘false’.

A felület csak azt írja le, hogy ez a viselkedés hogy fog látszani, és hogyan kezelhető a külvilág számára. Absztrakt fogalom, nem tudjuk, hogy a fingásra képes élőlények hogyan finganak, de azt tudjuk, hogyan kell kezelni a helyzetet. Comprende?

Nézzük tovább:

public abstract Animal : IFarter
{
  abstract bool DoFart();
 
  event EventHandler<ShitFlowingOnMyLegEventArgs> ShitFlowingOnMyLeg;
}

Az állat absztrakt osztályfogalom, mert ebből fog származni minden konkrét állatfaj, de itt már jelezhetjük a felület megvalósíátást (és megvalósíthatjuk absztrakt módon), mert akinek bele van, az fingani is fog. Ebből az osztályból lehet származtatni a szamarat, és a legnagyobb állatot az embert. Mindegyik ismerni fogja az IFarter felületet. De akkor mire jó a felület, miért nem elég csak az absztrakt ős?
Mit tud egy fingópárna? Na? Bingó: fingani, mint a gép! (Maximum nem fo…kakilja le a lába szárát, de az eseményt nem kötelező meghívni):

public sealed class FartPillow : IFarter
{
  public bool DoFart()
  {
    // Itt implementalja a belso f1ng0mechanizmust
  }
 
  event EventHandler<ShitFlowingOnMyLegEventArgs> ShitFlowingInMyLeg;
  // ezzel meg nem foglalkozik, bar az uj modellek csodakra lehetnek kepesek
}

Anélkül, hogy az állatoknak és egy teljesen más alapokon nyugvó fingó párnak közös őstől kellett volna származtatni, tudunk belőlük kezelni egy egységes, nagy és összetartó fingó közösséget, akinek minden tagja eregeti a buborékot, de nagyon durván. Ezeket be tudjuk állítani egy sorba:

List<IFarter> faterList = new List<IFater>();

Bele tudjuk dobni egy gödörbe:

Stack<IFater> farterStack = new Stack<IFater>();

Mind a gödör, mind a sor megvalósítja az IEnumaerable felületet, amin keresztül tudjuk iterálni a benne lévő elemeket, és a benne lévő elemek megvalósítják az IFarter feleületet, szóval tudnak fingani, ezért:

foreach (IFarter farter in faterList) // IEnumerable<T>-t hasznal a foreach!
{
  farter.DoFart();
}
 
foreach (IFarter farter in faterStack)
{
  farter.DoFart();
}

Hála a interfészeknek van egységes felület, amin a hasonló viselkedéssel, de teljesen más megvalósítással rendelkező objektumokat képesek vagyunk azonos módon (mindenféle cast-elések nélkül) kezelni.

Durván ennyi.

írta: Chikk