C# Abstract Class: Abstract Methods, Examples and vs Interface

An abstract class is a class that exists only to be derived from. It cannot be instantiated, and it can declare abstract members: methods and properties with no body that every concrete derived class must implement. Everything else about it is an ordinary class: it can have fields, constructors and fully implemented methods that derived classes inherit.

Declaring an abstract class

Mark the class abstract, and mark each member that derived classes must supply abstract, ending it with a semicolon instead of a body:

using System;
using System.Collections.Generic;

abstract class Shape
{
    public string Label { get; }

    protected Shape(string label) { Label = label; }

    public abstract double Area();              // no body: each shape must implement it
    public abstract double Perimeter();

    public string Describe() =>                 // shared, concrete method
        $"{Label}: area {Area():F2}, perimeter {Perimeter():F2}";
}

class Circle : Shape
{
    private readonly double radius;
    public Circle(double radius) : base("Circle") { this.radius = radius; }

    public override double Area() => Math.PI * radius * radius;
    public override double Perimeter() => 2 * Math.PI * radius;
}

class Rectangle : Shape
{
    private readonly double width, height;
    public Rectangle(double w, double h) : base("Rectangle") { width = w; height = h; }

    public override double Area() => width * height;
    public override double Perimeter() => 2 * (width + height);
}

class Program
{
    static void Main()
    {
        var shapes = new List<Shape> { new Circle(1.5), new Rectangle(4, 2.5) };
        foreach (Shape s in shapes)
            Console.WriteLine(s.Describe());

        // var s2 = new Shape("blob"); // error CS0144: Cannot create an instance of the abstract type or interface 'Shape'
    }
}

Output:

Circle: area 7.07, perimeter 9.42
Rectangle: area 10.00, perimeter 13.00

Describe is written once, in the base class, and calls Area and Perimeter, which do not exist in Shape at all. That is the point of an abstract member: the base class can rely on it, and the compiler guarantees every concrete shape provides it. A derived class that forgets one does not compile:

class Triangle : Shape
{
    public Triangle() : base("Triangle") { }
    public override double Area() => 6;
}
// error CS0534: 'Triangle' does not implement inherited abstract member 'Shape.Perimeter()'

The fix is to implement Perimeter, or to mark Triangle itself abstract if it is an intermediate base for further classes.

Rules for abstract members

• An abstract member has no body and is implicitly virtual: derived classes implement it with override.
• Only abstract classes may contain abstract members. Putting one in a normal class is a compile error.
• Abstract members cannot be private (nobody could override them) or static in a class.
• Methods, properties, indexers and events can be abstract. Fields and constructors cannot.
• An abstract class does not have to contain any abstract member. Marking a class abstract alone just prevents instantiation, useful for a base class that only makes sense through its subclasses.

An abstract property declares which accessors the derived class must provide:

abstract class Plan
{
    public abstract decimal MonthlyPrice { get; }
    public abstract string Name { get; }
}

class ProPlan : Plan
{
    public override decimal MonthlyPrice => 12.99m;
    public override string Name => "Pro";
}

Constructors in abstract classes

An abstract class can have constructors. They cannot be called with new, but every derived constructor runs one through : base(...), so they are where shared state is initialized and validated. Declare them protected, which says exactly that: only derived classes can use this.

The template method pattern

The most common reason to write an abstract class is to fix the order of an algorithm in the base class and let derived classes fill in individual steps. The base method that runs the steps is not virtual, so no subclass can reorder or skip them.

using System;
using System.Collections.Generic;
using System.Text;

abstract class OrderExporter
{
    // The template: the steps and their order are fixed here.
    public string Export(IEnumerable<(string Item, int Qty, decimal Price)> rows)
    {
        var sb = new StringBuilder();
        sb.Append(Header());
        decimal total = 0;
        foreach (var r in rows)
        {
            sb.Append(Row(r.Item, r.Qty, r.Price));
            total += r.Qty * r.Price;
        }
        sb.Append(Footer(total));
        return sb.ToString();
    }

    protected abstract string Header();
    protected abstract string Row(string item, int qty, decimal price);
    protected virtual string Footer(decimal total) => "";   // optional step with a default
}

class CsvExporter : OrderExporter
{
    protected override string Header() => "item,qty,price\n";
    protected override string Row(string item, int qty, decimal price) => $"{item},{qty},{price}\n";
}

class MarkdownExporter : OrderExporter
{
    protected override string Header() => "| Item | Qty | Price |\n| --- | --- | --- |\n";
    protected override string Row(string item, int qty, decimal price) => $"| {item} | {qty} | {price} |\n";
    protected override string Footer(decimal total) => $"\nTotal: {total}\n";
}

class Program
{
    static void Main()
    {
        var rows = new List<(string, int, decimal)> { ("Coffee beans", 2, 11.50m), ("Filter papers", 1, 3.20m) };

        OrderExporter[] exporters = { new CsvExporter(), new MarkdownExporter() };
        foreach (var e in exporters)
            Console.Write(e.Export(rows) + "\n");
    }
}

Output:

item,qty,price
Coffee beans,2,11.50
Filter papers,1,3.20

| Item | Qty | Price |
| --- | --- | --- |
| Coffee beans | 2 | 11.50 |
| Filter papers | 1 | 3.20 |

Total: 26.20

Each row is a named tuple, and the output is built with a StringBuilder. Note the mix: Header and Row are abstract because every format must decide them, and Footer is virtual with an empty default because most formats need nothing there. The steps are protected, so outside code can only call Export. Framework classes use the same idea: Stream and TextWriter are abstract base classes whose many convenience methods are built on a few members a derived class supplies (Read and Write for a stream, Write(char) for a text writer).

Abstract class vs interface

Both let you write code against a type without knowing the concrete class. They differ in what they can contain and how many a class can have:

Default interface methods (C# 8) narrowed the gap, but not the core difference:

public interface ILogger
{
    void Write(string message);
    void Error(string message) => Write("ERROR: " + message);   // default implementation: C# 8, .NET Core 3.0+
}

A default method still cannot touch instance fields, because the interface has none; it can only call other members of the interface.

A practical way to choose:

• Interface when you describe a capability that unrelated types can have (IComparable<T>, IDisposable, IShippingProvider), when structs should be able to take part, or when a class needs several such roles. Most dependency injection code is written against interfaces for this reason.
• Abstract class when the derived types are genuinely variations of one thing and share state or a fixed algorithm, like the exporters above.
• Both is common: an interface for callers to depend on, and an abstract base class that implements it and saves implementers from rewriting the shared parts. The interfaces page covers the interface side in detail.

Common mistakes

• Trying to instantiate the base class. new Shape(...) is CS0144. Instantiate a derived class.
• Forgetting override on the implementation. Writing public double Area() in the derived class does not implement the abstract member; the compiler reports CS0534 for the missing implementation, plus a warning that the new method hides the inherited one.
• A public constructor on an abstract class. Harmless but misleading. Use protected.
• Abstract classes with no shared code. If the base class has only abstract members and no state, an interface says the same thing and does not use up the single base class slot.
• Calling abstract members from the base constructor. The derived implementation runs before the derived constructor's body, so fields that body assigns are still 0 or null.