> ## 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. # C# Abstract Method An abstract method in C# is a method declared with the `abstract` modifier that contains no implementation and forces any non-abstract (concrete) derived type to provide its own implementation. It acts as a strict contractual signature that defines the method's access level, return type, name, and parameters without defining its behavior. ```csharp theme={"dark"} 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 { // 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`), 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. ```csharp theme={"dark"} 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); } } ```

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More