C#接口和基类

Question

我有一个C#接口,以及一个实现该接口的具体类.我现在想要创建另一个实现该接口的类.很简单.

但是,大多数方法在类中都是完全相同的,只有几种方法实际上会发生变化.

我不想复制第一个包含在我的第二个类中的所有逻辑.

如何创建第二个类,并在我的第一个类中使用逻辑,除了额外的东西？

我的界面叫做IEventRepository,我的第一个类叫做BaseEvents.我现在想创建一个名为FooBarEvents的新类.

我对FooBarEvents的类定义是:

public class FooBarEvents : BaseEvents, IEventRepository

我的意图是在每个重复代码的方法中使用return base.Method().

我假设这不正确？

Answer 1

FooBarEvents应该只需要继承BaseEvents,而不是实现IEventRepository,因为BaseEvents已经实现了接口.如果需要更改某些IEventRepository方法的行为FooBarEvents,只需覆盖这些方法即可.

编辑:一些例子

interface IEventRepository
{
   void CommonMethodA();
   void CommonMethodB();
   void ImplentationSpecificMethod();
}

abstract class BaseEvents : IEventRepository
{
   public void CommonMethodA()
   { ... }

   public virtual void CommonMethodB()
   { ... }

   public abstract void ImplementationSpecificMethod();

   public void BaseEventsMethod()
   { ... }

   public void BaseEventsMethod2()
   { ... }
}

class FooBarEvents : BaseEvents
{
   public override void CommonMethodB()
   { 
      // now FooBarEvents has a different implementation of this method than BaseEvents
   }

   public override void ImplementationSpecificMethod()
   { 
      // this must be implemented
   }

   public new void BaseEventsMethod2()
   { 
      // this hides the implementation that BaseEvents uses
   }

   public void FooBarEventsMethod()
   { 
      // no overriding necessary
   }
}

// all valid calls, assuming myFooBarEvents is instantiated correctly
myFooBarEvents.CommonMethodA()
myFooBarEvents.CommonMethodB()
myFooBarEvents.BaseEventsMethod();
myFooBarEvents.BaseEventsMethod2();
myFooBarEvents.FooBarEventsMethod();
myFooBarEvents.ImplementationSpecificMethod();

// use the contract thusly:
void DoSomethingWithAnEventRepository(BaseEvents events)
{ ... }

Answer 2

由于BaseEvents已经实现IEventRepository,您不需要再次实现它FooBarEvents.FooBarEvents自动继承BaseEvents'实现.

Answer 3

以下代码演示如何使用抽象基类提供某些接口方法的通用实现，并为其他方法提供自定义实现。

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
    }
  }

}