120. Interfaces

C# LANGUAGE SPECIFICATION

120.1.2 Base interfaces

2An interface can inherit from one or more interfaces, which are called the explicit base interfaces of the

3interface. When an interface has one or more explicit base interfaces, then in the declaration of that interface,

4the interface identifier is followed by a colon and a comma-separated list of base interfaces.

5interface-base:

6: interface-type-list

7The explicit base interfaces can be constructed interface types (§26.5). A base interface cannot be a type

8parameter on its own, though it can involve the type parameters that are in scope.

9The explicit base interfaces (and any type arguments) of an interface shall be at least as accessible as the

10interface itself (§10.5.4). [Note: For example, it is a compile-time error to specify a private or internal

11interface in the interface-base of a public interface. end note]

12It is a compile-time error for an interface to directly or indirectly inherit from itself.

13The base interfaces of an interface are the explicit base interfaces and their base interfaces (after substituting

14type arguments for type parameters in constructed generic types). In other words, the set of base interfaces is

15the complete transitive closure of the explicit base interfaces, their explicit base interfaces, and so on. An

16interface inherits all members of its base interfaces. [Example: In the following code

17interface IControl

18{

19void Paint();

20}

21interface ITextBox: IControl

22{

23void SetText(string text);

24}

25interface IListBox: IControl

26{

27void SetItems(string[] items);

28}

29interface IComboBox: ITextBox, IListBox {}

30the base interfaces of IComboBox are IControl, ITextBox, and IListBox. In other words, the

31IComboBox interface above inherits members SetText and SetItems as well as Paint. end example]

32Members inherited from a constructed generic type are inherited after type substitution. That is, any

33constituent types in the member have the base class declaration’s type parameters replaced with the

34corresponding type arguments used in the class-base specification. [Example: In the following code

35interface IBase<T>

36{

37T[] Combine(T a, T b);

38}

39interface IDerived : IBase<string[,]>

40{

41// Inherited: string[][,] Combine(string[,] a, string[,] b);

42}

43the interface IDerived inherits the Combine method after the type parameter T is replaced with

44string[,]. end example]

45A class or struct that implements an interface also implicitly implements all of the interface’s base

46interfaces.

47The handling of interfaces on multiple parts of a partial interface declaration (§17.1.4) are discussed further

48in §17.1.2.2.

4920.1.3 Interface body

50The interface-body of an interface defines the members of the interface.

336