Design and Architecture

Quote:

A class that inherits from an abstract class cannot access the original implementation of a method

public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

netfed wrote:

abstract classes without any implementations just look like Interfaces

netfed wrote:

A class that inherits from an abstract class cannot access the original implementation of a method

abstract class A
{
  // 2) A doesn't store the label content - a derived must
  abstract string Label {get;};

  string ToLabel()
  {
    // 1) Implementation centralized - not in all derived classes
    return this.Label;
  }

  // 3) implementation that can be extended or even replaced
  virtual void Writeline()
  {
    Console.Out.Writeline();
  }
}

class X : A
{
  // 2) A says I must do this - I at least choose the content
  override string Label{ get{ return "I am X!"; }}
  
}

class Y : A
{
  // 2) A says I must do this - I at least choose the content
  override string Label{ get{ return "Me is Y!"; }}

  // 3) optionally extending implementation in abstract class
  override void Writeline()
  {
     Console.Out.Writeline(">>>"); // extra before base
     base.Writeline();
     Console.Out.Writeline("<<<"); // extra after base
  }
}

void SomeCode()
{
  // 4) Polymorphism - declaring a collection of abstract classes but adding instances of derived classes
  List<A> as = new List<A>();
  as.Add(new X());
  as.Add(new Y());
  foreach(A a in as) // 4 - accessing abstract implementation
  {
    Console.Out.Writeline(a.ToLabel); // 4 - no branching on implementation e.g. typeof(X) or typeof(Y)
  }
}

Antonio Ripa wrote:

but a programming best practice

jschell wrote:

"best practice"