When an instance method declaration includes an abstract modifier, that
method is said to be an abstract
method. Although an abstract method is implicitly also a virtual method, it
cannot have the modifier virtual.
An abstract method declaration introduces a new virtual method but does not
provide an implementation of that
method. Instead, non-abstract derived classes are required to provide their
own implementation by overriding that
method. Because an abstract method provides no actual implementation, the
method-body of an abstract method
simply consists of a semicolon.
Abstract method declarations are only permitted in abstract classes (§17.1.1
.1).
[Example: In the example
public abstract class Shape
{
public abstract void Paint(Graphics g, Rectangle r);
}
public class Ellipse: Shape
{
public override void Paint(Graphics g, Rectangle r) {
g.DrawEllipse(r);
}
}
public class Box: Shape
{
public override void Paint(Graphics g, Rectangle r) {
g.DrawRect(r);
}
}
the Shape class defines the abstract notion of a geometrical shape object
that can paint itself. The Paint method
is abstract because there is no meaningful default implementation. The
Ellipse and Box classes are concrete
Shape implementations. Because these classes are non-abstract, they are
required to override the Paint method
and provide an actual implementation. end example]
It is a compile-time error for a base-access (§14.5.8) to reference an
abstract method. [Example: In the example
abstract class A
{
public abstract void F();
}
C# LANGUAGE SPECIFICATION
238
class B: A
{
public override void F() {
base.F(); // Error, base.F is abstract
}
}
a compile-time error is reported for the base.F() invocation because it
references an abstract method. end
example]
An abstract method declaration is permitted to override a virtual method.
This allows an abstract class to force reimplementation
of the method in derived classes, and makes the original implementation of
the method
unavailable. [Example: In the example
using System;
class A
{
public virtual void F() {
Console.WriteLine("A.F");
}
}
abstract class B: A
{
public abstract override void F();
}
class C: B
{
public override void F() {
Console.WriteLine("C.F");
}
}
class A declares a virtual method, class B overrides this method with an
abstract method, and class C overrides
that abstract method to provide its own implementation. end example]
17.5.7 External methods
When a method declaration includes an extern modifier, the method is said
to be an external method. External
methods are implemented externally, typically using a language other than
C#. Because an external method
declaration provides no actual implementation, the method-body of an
external method simply consists of a
semicolon.
The mechanism by which linkage to an external method is achieved, is
implementation-defined.
[Example: The following example demonstrates the use of the extern modifier
in combination with a
DllImport attribute that specifies the name of the external library in
which the method is implemented:
using System.Text;
using System.Security.Permissions;
using System.Runtime.InteropServices;
class Path
{
[DllImport("kernel32", SetLastError=true)]
static extern bool CreateDirectory(string name, SecurityAttribute sa);
[DllImport("kernel32", SetLastError=true)]
static extern bool RemoveDirectory(string name);
[DllImport("kernel32", SetLastError=true)]
static extern int GetCurrentDirectory(int bufSize, StringBuilder buf);
[DllImport("kernel32", SetLastError=true)]
static extern bool SetCurrentDirectory(string name);
}
end example]
