320.2 Interface members

4The members of an interface are the members inherited from the base interfaces and the members declared

5by the interface itself.

6interface-member-declarations:

14An interface declaration can declare zero or more members. The members of an interface shall be methods,

15properties, events, or indexers. An interface cannot contain constants, fields, operators, instance

16constructors, destructors, or types, nor can an interface contain static members of any kind.

17All interface members implicitly have public access. It is a compile-time error for interface member

18declarations to include any modifiers. In particular, interface members cannot be declared with the modifiers

19abstract, public, protected, internal, private, virtual, override, or static.

20[Example: The example

21public delegate void StringListEventHandler(IStringList sender,

22ListEventArgs e);

23public interface IStringList

24{

28string this[int index] { get; set; }

29}

30declares an interface that contains one each of the possible kinds of members: A method, a property, an

31event, and an indexer. end example]

32An interface-declaration creates a new declaration space (§10.3), and the type parameters and interface-

33member-declarations immediately contained by the interface-declaration introduce new members into this

34declaration space. The following rules apply to interface-member-declarations:

35• The name of a type parameter in the type-parameter-list of an interface declaration shall differ from the

36names of all other type parameters in the same type-parameter-list and shall differ from the names of all

37members of the interface.

38• The name of a method shall differ from the names of all properties and events declared in the same

39interface. In addition, the signature (§10.6) of a method shall differ from the signatures of all other

40methods declared in the same interface, and two methods declared in the same interface shall not have

41signatures that differ solely by ref and out.

42• The name of a property or event shall differ from the names of all other members declared in the same

43interface.

44• The signature of an indexer shall differ from the signatures of all other indexers declared in the same

45interface.

46The inherited members of an interface are specifically not part of the declaration space of the interface.

47Thus, an interface is allowed to declare a member with the same name or signature as an inherited member.

337

C# LANGUAGE SPECIFICATION

1When this occurs, the derived interface member is said to hide the base interface member. Hiding an

2inherited member is not considered an error, but it does cause the compiler to issue a warning. To suppress

3the warning, the declaration of the derived interface member shall include a new modifier to indicate that the

4derived member is intended to hide the base member. This topic is discussed further in §10.7.1.2.

5If a new modifier is included in a declaration that doesn’t hide an inherited member, a warning is issued to

6that effect. This warning is suppressed by removing the new modifier.

7[Note: The members in class object are not, strictly speaking, members of any interface (§20.2). However,

8the members in class object are available via member lookup in any interface type (§14.3). end note]

9For a discussion about members of an interface declared in multiple parts (§17.1.4), see §17.2.

1020.2.1 Interface methods

11Interface methods are declared using interface-method-declarations:

12interface-method-declaration:

15The attributes, return-type, identifier, and formal-parameter-list of an interface method declaration have the

16same meaning as those of a method declaration in a class (§17.5). An interface method declaration is not

17permitted to specify a method body; therefore the declaration always ends with a semicolon. An interface-

18method-declaration shall not have type-parameter-constraints-clauses unless it also has a type-parameter-

19list.

2020.2.2 Interface properties

21Interface properties are declared using interface-property-declarations:

22interface-property-declaration:

29The attributes, type, and identifier of an interface property declaration have the same meaning as those of a

30property declaration in a class (§17.6).

31The accessors of an interface property declaration correspond to the accessors of a class property declaration

32(§17.6.2), except that the accessor body shall always be a semicolon. Thus, the accessors simply indicate

33whether the property is read-write, read-only, or write-only.

3420.2.3 Interface events

35Interface events are declared using interface-event-declarations:

36interface-event-declaration:

38The attributes, type, and identifier of an interface event declaration have the same meaning as those of an

39event declaration in a class (§17.7).

4020.2.4 Interface indexers

41Interface indexers are declared using interface-indexer-declarations:

42interface-indexer-declaration:

338

Chapter 20 Interfaces

1The attributes, type, and formal-parameter-list of an interface indexer declaration have the same meaning as

2those of an indexer declaration in a class (§17.8).

3The accessors of an interface indexer declaration correspond to the accessors of a class indexer declaration

4(§17.8), except that the accessor body shall always be a semicolon. Thus, the accessors simply indicate

5whether the indexer is read-write, read-only, or write-only.

620.2.5 Interface member access

7Interface members are accessed through member access (§14.5.4) and indexer access (§14.5.6.2) expressions

8of the form I.M and I[A], where I is an expression having an interface type, M is a method, property, or

9event of that interface type, and A is an indexer argument list.

10For interfaces that are strictly single-inheritance (each interface in the inheritance chain has exactly zero or

11one direct base interface), the effects of the member lookup (§14.3), method invocation (§14.5.5.1), and

12indexer access (§14.5.6.2) rules are exactly the same as for classes and structs: More derived members hide

13less derived members with the same name or signature. However, for multiple-inheritance interfaces,

14ambiguities can occur when two or more unrelated base interfaces declare members with the same name or

15signature. This subclause shows several examples of such situations. In all cases, explicit casts can be used

16to resolve the ambiguities.

17[Example: In the following code

18interface IList

19{

20int Count { get; set; }

21}

22interface ICounter

23{

24void Count(int i);

25}

26interface IListCounter: IList, ICounter {}

27class C

28{

34}

35}

36the first two statements cause compile-time errors because the member lookup (§14.3) of Count in

37IListCounter is ambiguous. As illustrated by the example, the ambiguity is resolved by casting x to the

38appropriate base interface type. Such casts have no run-time costs—they merely consist of viewing the

39instance as a less derived type at compile-time. end example]

40[Example: In the following code

41interface IInteger

42{

43void Add(int i);

44}

45interface IDouble

46{

47void Add(double d);

48}

49interface INumber: IInteger, IDouble {}

339