C# - Interface-und base-Klassen

Seit BaseEvents bereits implementiert IEventRepository Sie nicht implementieren müssen, um es wieder in FooBarEvents. FooBarEvents erbt automatisch BaseEvents Umsetzung.

Folgende code zeigt, wie eine gemeinsame Umsetzung einiger Methoden der Schnittstelle mit einer abstrakten Basisklasse, und benutzerdefinierte Implementierungen für andere.

public interface IEventRepository
{
  void Method1();
  void Method2();
}

public abstract class BaseEvents : IEventRepository
{
  public void Method1() 
  {
    Console.WriteLine("This is shared functionality");
  }

  public abstract void Method2();
}

public class Implementation1 : BaseEvents
{
  override public void Method2()
  {
    Console.WriteLine("Impl1.Method2");
  }
}

public class Implementation2 : BaseEvents
{
  override public void Method2()
  {
    Console.WriteLine("Impl2.Method2");
  }
}

public class Program
{
  static void Main(string[] args)
  {
    var implementations = new List<IEventRepository> { new Implementation1(), new Implementation2() };

    foreach (var i in implementations) 
    {
       Console.WriteLine(i.GetType().Name);
       Console.Write("\t");
       i.Method1();  //writes 'This is shared functionality'

       Console.Write("\t");
       i.Method2(); //writes type specific message
    }
  }

}

Verwenden Sie Vererbung:

public interface IFoo
{
    void GeneralBehaviorMethod1();
    void GeneralBehaviorMethod2();
    void SpecificBehaviorMethod1();
}

public class Bar: IFoo
{
     public void GeneralBehaviorMethod1() {...}
     public void GeneralBehaviorMethod2() {...}

     public virtual void SpecificBehaviorMethod1() {...}
     ...
}

public class BarOnSteroids: Bar
{
    public override void SpecificBehaviorMethod1() {...}
}

BarOnSteroids wird alles Erben, Verhalten Bar und Sie verändern können das spezifische Verhalten von Methoden, die Sie benötigen, durch überschreiben Sie in BarOnSteroids (Sie müssen gekennzeichnet werden als virtual in der Basisklasse Bar).

Diese Weise würden Sie haben die folgenden:

IFoo iFoo = new Bar();
iFoo.SpecificBehaviorMethod1(); //Bar implementation will be called;

IFoo iFoo = new BarOnSteroids();
iFoo.SpecificBehaviorMethod1(); //BarOnSteroids implementation will be called.
iFoo.CommonBehaviorMethod1(); //Bar implementation will be called.

Bar bar = new BarOnSteroids();
bar.SpecificBehaviorMethod1(); //BarOnSteroids implementation will be called.
bar.CommonBehaviorMethod1(); //Bar implementation will be called.

Dies setzt Voraus, Sie ändern möchten spezifische Verhalten von Methoden, die ein Teil der IFoo - Schnittstelle. Wenn alles, was Sie wollen, ist, um zusätzliche Funktionalität hinzufügen, um BarOnSteroids dann einfach Erben form Bar zu Erben all seiner Funktionen, und fügen Sie alle erforderlichen neuen Methoden für die Umsetzung der neuen Funktionalität.

Gibt es ein paar verschiedene Ansätze.

Einer. Überspringen Sie die Oberfläche vollständig, und machen es eine abstrakte Klasse. Dies ist einfacher, wenn es funktioniert, aber die Tatsache, dass Sie können nur eine Basis-Klasse schränkt die Verwendung in C#

public abstract class EventRepository
{
  public abstract int MustBeOverridden(string str);//classes have to override this
  public virtual int CanBeOverridden(int i)//classes can override but may choose not to.
  {
    return 4;
  }
  public int CannotOverride(string str)//this is always the same
  {
    return MustBeOverridden(str) + 3;//can make use of this
  }
}

Können Sie eine Klasse, die die Schnittstelle implementieren, und eine andere daraus ziehen:

public interface IEventRepository
{
  int Method1(string str);
  int Method2(string str);
}

public class EventClass1 : IEventRepository
{
  public int Method1(string str)//can't be overridden as not marked virtual
  {
    return 1;
  }
  public virtual int Method2(string str)//can be overridden
  {
    return 2;
  }
}

public class EventClass2 : EventClass1
{
  public override int Method2(string str)
  {
    return -2;
  }
}

Haben Sie beide überschreiben einer abstrakten Klasse, gibt es einige gemeinsame Verhaltensweisen:

public abstract class EventClass : IEventRepository
{
  public abstract int Method1(string str);
  public int Method2(string str)
  {
    return 2;
  }
}

public class EventClass1 : EventClass
{
  public override int Method1(string str)
  {
    return 1;
  }
}
public class EventClass2 : EventClass
{
  public override int Method1(string str)
  {
    return -1;
  }
}

Könnten Sie auch eine statische helper-Klasse, die nichts zu tun hat mit der Hierarchie, aber nicht, Methoden bereitzustellen, die nützlich sind bei der Umsetzung der Funktionalität.

Seien Sie vorsichtig wenn Sie dieses Muster:

public class EventClass1 : IEventRepository
{
  public int Method1(string str)//not override-able
  {
    return 1;
  }
  public int Method2(string str)//not override-able
  {
    return 2;
  }
}
public class EventClass2 : EventClass1, IEventRepository
{
  //We really want our own Method1!
  public new int Method1(string str)
  {
    return 3;
  }
  int IEventRepository.Method1(string str)
  {
    return -1;
  }
}

EventClass2 e2 = new EventClass2();
EventClass1 e1 = e2;
IEventRepository ie = e2;
Console.WriteLine(e2.Method1(null));//3
Console.WriteLine(e1.Method1(null));//1
Console.WriteLine(ie.Method1(null));//-1

Selbst wenn IEventRepository.Method1 definiert ist sinnvoller, die oben ist wahrscheinlich zu Verwirrung führen.