14.3 Member lookup

A member lookup is the process whereby the meaning of a name in the context
of a type is determined. A
member lookup may occur as part of evaluating a simple-name (?4.5.2) or a
member-access (?4.5.4) in an
expression.
A member lookup of a name N in a type T is processed as follows:
?First, the set of all accessible (?0.5) members named N declared in T
and the base types (?4.3.1) of T
is constructed. Declarations that include an override modifier are excluded
from the set. If no
members named N exist and are accessible, then the lookup produces no
match, and the following steps
are not evaluated.
?Next, members that are hidden by other members are removed from the set.
For every member S.M in
the set, where S is the type in which the member M is declared, the
following rules are applied:
If M is a constant, field, property, event, type, or enumeration member,
then all members declared in a base
type of S are removed from the set.
If M is a method, then all non-method members declared in a base type of S
are removed from the set, and all
methods with the same signature as M declared in a base type of S are
removed from the set.
?Finally, having removed hidden members, the result of the lookup is
determined:
If the set consists of a single non-method member, then this member is the
result of the lookup.
Otherwise, if the set contains only methods, then this group of methods is
the result of the lookup.
Otherwise, the lookup is ambiguous, and a compile-time error occurs (this
situation can only occur for a
member lookup in an interface that has multiple direct base interfaces).
For member lookups in types other than interfaces, and member lookups in
interfaces that are strictly singleinheritance
(each interface in the inheritance chain has exactly zero or one direct
base interface), the effect of
the lookup rules is simply that derived members hide base members with the
same name or signature. Such
single-inheritance lookups are never ambiguous. The ambiguities that can
possibly arise from member
lookups in multiple-inheritance interfaces are described in ?0.2.5.