Export (0) Print
Expand All

abstract (C# Reference)

The abstract modifier can be used with classes, methods, properties, indexers, and events. Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.

In this example, the class Square must provide an implementation of Area because it derives from ShapesClass:


      abstract class ShapesClass
{
    abstract public int Area();
}
class Square : ShapesClass
{
    int x, y;
    // Not providing an Area method results
    // in a compile-time error.
    public override int Area()
    {
        return x * y;
    }
}

For more information about abstract classes, see Abstract and Sealed Classes and Class Members (C# Programming Guide).

Abstract classes have the following features:

  • An abstract class cannot be instantiated.

  • An abstract class may contain abstract methods and accessors.

  • It is not possible to modify an abstract class with the sealed (C# Reference) modifier, which means that the class cannot be inherited.

  • A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.

Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.

Abstract methods have the following features:

  • An abstract method is implicitly a virtual method.

  • Abstract method declarations are only permitted in abstract classes.

  • Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no curly braces ({ }) following the signature. For example:

    public abstract void MyMethod();
    
  • The implementation is provided by an overriding methodoverride (C# Reference), which is a member of a non-abstract class.

  • It is an error to use the static or virtual modifiers in an abstract method declaration.

Abstract properties behave like abstract methods, except for the differences in declaration and invocation syntax.

  • It is an error to use the abstract modifier on a static property.

  • An abstract inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

An abstract class must provide implementation for all interface members.

An abstract class that implements an interface might map the interface methods onto abstract methods. For example:

interface I 
{
    void M();
}
abstract class C: I 
{
    public abstract void M();
}

In this example, the class DerivedClass is derived from an abstract class BaseClass. The abstract class contains an abstract method, AbstractMethod, and two abstract properties, X and Y.

// abstract_keyword.cs
// Abstract Classes
using System;
abstract class BaseClass   // Abstract class
{
    protected int _x = 100;
    protected int _y = 150;
    public abstract void AbstractMethod();   // Abstract method
    public abstract int X    { get; }
    public abstract int Y    { get; }
}

class DerivedClass : BaseClass
{
    public override void AbstractMethod()
    {
        _x++;
        _y++;
    }

    public override int X   // overriding property
    {
        get
        {
            return _x + 10;
        }
    }

    public override int Y   // overriding property
    {
        get
        {
            return _y + 10;
        }
    }

    static void Main()
    {
        DerivedClass o = new DerivedClass();
        o.AbstractMethod();
        Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
    }
}

Output

 
x = 111, y = 161

In the preceding example, if you attempt to instantiate the abstract class by using a statement like this:

BaseClass bc = new BaseClass();   // Error

you will get an error saying that the compiler cannot create an instance of the abstract class 'BaseClass'.

For more information, see the following sections in the C# Language Specification:

  • 1.6.5.4 Virtual, override, and abstract methods

  • 10.1.1.1 Abstract classes

Community Additions

ADD
Show:
© 2014 Microsoft