IT. Expert System.

C#

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 can occur as part of evaluating a simple-name or a member-access in an expression. If the simple-name or member-access occurs as the simple-expression of an invocation-expression , the member is said to be invoked.

If a member is a method or event, or if it is a constant, field or property of a delegate type , then the member is said to be invocable.

Member lookup considers not only the name of a member but also the number of type parameters the member has and whether the member is accessible. For the purposes of member lookup, generic methods and nested generic types have the number of type parameters indicated in their respective declarations and all other members have zero type parameters.

A member lookup of a name N with K type parameters in a type T is processed as follows:

  • First, a set of accessible members named N is determined:

  • If T is a type parameter, then the set is the union of the sets of accessible members named N in each of the types specified as a primary constraint or secondary constraint for T, along with the set of accessible members named N in object.

  • Otherwise, the set consists of all accessible members named N in T, including inherited members and the accessible members named N in object. If T is a constructed type, the set of members is obtained by substituting type arguments as described in §10.3.2. Members that include an override modifier are excluded from the set.

  • Next, if K is zero, all nested types whose declarations include type parameters are removed. If K is not zero, all members with a different number of type parameters are removed. Note that when K is zero, methods having type parameters are not removed, since the type inference process might be able to infer the type arguments.

  • Next, if the member is invoked, all non-invocable members are removed from the set.

  • 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, or enumeration member, then all members declared in a base type of S are removed from the set.

  • If M is a type declaration, then all non-types declared in a base type of S are removed from the set, and all type declarations with the same number of type parameters as M 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.

  • Next, interface members that are hidden by class members are removed from the set. This step only has an effect if T is a type parameter and T has both an effective base class other than object and a non-empty effective interface 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 S is a class declaration other than object:

  • If M is a constant, field, property, event, enumeration member, or type declaration, then all members declared in an interface declaration are removed from the set.

  • If M is a method, then all non-method members declared in an interface declaration are removed from the set, and all methods with the same signature as M declared in an interface declaration are removed from the set.

  • Finally, having removed hidden members, the result of the lookup is determined:

  • If the set consists of a single member that is not a method, 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.

For member lookups in types other than type parameters and interfaces, and member lookups in interfaces that are strictly single-inheritance (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 §13.2.5.

      1. Base types

For purposes of member lookup, a type T is considered to have the following base types:

  • If T is object, then T has no base type.

  • If T is an enum-type, the base types of T are the class types System.Enum, System.ValueType, and object.

  • If T is a struct-type, the base types of T are the class types System.ValueType and object.

  • If T is a class-type, the base types of T are the base classes of T, including the class type object.

  • If T is an interface-type, the base types of T are the base interfaces of T and the class type object.

  • If T is an array-type, the base types of T are the class types System.Array and object.

  • If T is a delegate-type, the base types of T are the class types System.Delegate and object.



Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 208 / 158770825. Delta: 0.02070 с