Abstract Method

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

using System;

public abstract class BaseClass
{
    // Abstract method declaration ends with a semicolon, no method body
    public abstract void ExecuteTask(int taskId);
}

public class DerivedClass : BaseClass
{
    // Mandatory implementation using the 'override' keyword
    public override void ExecuteTask(int taskId)
    {
        Console.WriteLine($"Executing task: {taskId}");
    }
}

public interface IMathematical<T>
{
    // C# 11: static abstract method in an interface
    static abstract T Add(T left, T right);
}

​

Technical Rules and Mechanics

• Enclosing Type: An abstract method can be declared within an abstract class or an interface (explicit abstract modifier support in interfaces was introduced in C# 8.0). Attempting to declare an abstract method in a standard (non-abstract) class or struct will result in compiler error CS0513.
• No Method Body: The method declaration must terminate with a semicolon (;). It cannot contain a statement block ({ }).
• Mandatory Implementation: Any concrete class inheriting from an abstract base class must implement the abstract method using the override keyword. If the derived class is also declared as abstract, the implementation is optional and can be deferred further down the inheritance chain.
• Implicitly Virtual: Abstract instance methods are inherently virtual, meaning they participate in polymorphic dispatch. However, it is a syntax error to explicitly combine the abstract and virtual modifiers.
• Access Modifiers: An abstract method cannot be declared as private because derived types must be able to inherit and implement it. Valid access modifiers include public, protected, internal, protected internal, and private protected (introduced in C# 7.2).
• Static Abstract: Since C# 11, the abstract modifier can be combined with static exclusively within interfaces to define static polymorphic contracts. Abstract methods within classes cannot be static.
• Prohibited Modifiers: An abstract method cannot be combined with extern or sealed modifiers. (Note: A derived class can apply the sealed modifier to its override implementation to prevent further overriding).
• The Async Modifier: An abstract method cannot be marked with the async modifier (compiler error CS1994). Because async is an implementation detail that instructs the compiler to generate a state machine, it cannot be applied to a signature without a body. Instead, the abstract method should return an awaitable type (such as Task or Task<T>), and the derived class can apply the async modifier to its override implementation.
• Abstract Override: In a derived abstract class, the abstract modifier can be combined with override. This syntax “un-implements” a virtual method inherited from a base class, stripping away its default behavior and forcing any further concrete derived classes to provide a new implementation.
• Properties and Indexers: The abstract modifier can also be applied to properties, indexers, and events, subjecting them to the exact same implementation rules as abstract methods.

using System.Threading.Tasks;

public class StandardBase
{
    public virtual void ProcessData() { }
}

public abstract class AdvancedBase : StandardBase
{
    // "Un-implementing" a virtual method using abstract override
    public abstract override void ProcessData();

    // Returning an awaitable type without the 'async' modifier
    public abstract Task FetchDataAsync();
}

public class ConcreteClass : AdvancedBase
{
    // Mandatory re-implementation of the un-implemented virtual method
    public override void ProcessData() { }

    // Applying 'async' to the concrete implementation
    public async override Task FetchDataAsync()
    {
        await Task.Delay(10);
    }
}