C# 仅在选定的派生类中使用基类方法

Question

I have common functions that should be used by certain derived classes only. To code each function only once, I use a base class. I need to define the functions as protected to hide them in the derived classes that do not use them, so there is no way of using virtual and override, cause the protection level can not be changed in this case. Here is my code. That works the way I weant it to, but ios there no better way to do that ?

  class Base
  {
    protected void Initialize()
    {
    }

    protected void doTask1()
    {
    }

    protected void doTask2()
    {
    }
}

class Derived1 : Base
{
    public void Initialize()
    {
        base.Initialize();
    }

    public new void doTask1()
    {
        base.doTask1();  
    }
}

class Derived2 : Base
{
    public void Initialize()
    {
        base.Initialize();
    }

    public new void doTask2()
    {
        base.doTask2();
    }
}

Any help is welcome ...

doTask1() should only be available in class Derived1 and doTask2() only in class Derived2. Thanks to the answer of @Fildor I solved it using interfaces. All derived classes derive from the same base class. The base class implements all functions in the interfaces.

public class Base : I_Derived1, I_Derived2 
{
  // implementations of all methods ...
  doTask1()  
  {  // ...   
  }
  doTask2()  
  {  // ...   
  }
  initialize()   
  {  // ...   
  }
{

public interface I_Derived1
{
  doTask1();
  initialize();
}
public interface I_Derived2
{
  doTask2();
  initialize();
}

class Derived1 : Base
{
}
class Derived2 : Base
{
}

// then the interfaces are used ...

I_Derived1 d1 = new Base();
I_Derived2 d2 = new Base();

d1.doTask1();
d2.initialize();
d2.doTask2();
// ...

This solved my problem, Thanks. In my real project some of the class Base functions are used by 10 or more derived classes, some by all and some only by 2 or 3. The user gets a DLL which serves him Lists of instances of a derived class, each instance allowing him to use the functions tnhat make sense for it.

Answer 1

I think you would be better off with just Interfaces here:

public interface IInit{
  void Initialize();
}

public interface I1: IInit {
   void DoTask1();
}

public interface I2: IInit {
   void DoTask2();
}

public class Impl: I1, I2
{
   public void Initialize() { /*...*/  }
   public void DoTask1(){ /*...*/  }
   public void DoTask2(){ /*...*/  }
}

usage:

Impl obj = new Impl();
obj.Initialize();
obj.DoTask1(); // both
obj.DoTask2(); // visible

I1 obj1 = new Impl();
obj1.Initialize();
obj1.DoTask1();
// obj1.DoTask2(); < not visible

I2 obj2 = new Impl();
obj2.Initialize();
// obj2.DoTask1(); < not visible
obj2.DoTask2();

You could even take this one step further with explicit interface implementations .