14.4 Function members

Function members are members that contain executable statements. Function   
                                          
members are always members                                                  
                                          
of types and cannot be members of namespaces. C# defines the following      
                                          
categories of function members:                                             
                                          
?Methods                                                                   
                                          
?Properties                                                                
                                          
?Events                                                                    
                                          
?Indexers                                                                  
                                          
?User-defined operators                                                    
                                          
?Instance constructors                                                     
                                          
?Static constructors                                                       
                                          
?Destructors                                                               
                                          
Except for static constructors and destructors (which cannot be invoked     
                                          
explicitly), the statements contained                                       
                                          
in function members are executed through function member invocations. The   
                                          
actual syntax for writing a                                                 
                                          
function member invocation depends on the particular function member        
                                          
category.                                                                   
                                          
The argument list (?4.4.1) of a function member invocation provides actual 
                                          
values or variable references                                               
                                          
for the parameters of the function member.                                  
                                          
Invocations of methods, indexers, operators, and instance constructors      
                                          
employ overload resolution to                                               
                                          
determine which of a candidate set of function members to invoke. This      
                                          
process is described in ?4.4.2.                                            
                                          
Once a particular function member has been identified at compile-time,      
                                          
possibly through overload                                                   
                                          
resolution, the actual run-time process of invoking the function member is  
                                          
described in ?4.4.3.                                                       
                                          
[Note: The following table summarizes the processing that takes place in    
                                          
constructs involving the six                                                
                                          
categories of function members that can be explicitly invoked. In the       
                                          
table, e, x, y, and value indicate                                          
                                          
expressions classified as variables or values, T indicates an expression    
                                          
classified as a type, F is the simple                                       
                                          
name of a method, and P is the simple name of a property.                   
                                          

Construct   Example     Description
-------------------------------------------------------------------------
Method      F(x, y)     Overload resolution is applied to select
invocation          the best method F in the containing class
                or struct. The method is invoked with the
                argument list (x, y). If the method is not
                static, the instance expression is this.
-------------------------------------------------------------------------   


   
        T.F(x, y)   Overload resolution is applied to select
                the best method F in the class or struct
                T. A compile-time error occurs if the
                method is not static. The method is invoked
                with the argument list (x, y).
-------------------------------------------------------------------------   
   
        e.F(x, y)   Overload resolution is applied to select the
                best method F in the class, struct, or
                interface given by the type of e. A
                compile-time error occurs if the method is
                static. The method is invoked with the
                instance expression e and the argument
                list (x, y).
-------------------------------------------------------------------------   
   
Property    P       The get accessor of the property P in the
access              containing class or struct is invoked. A
                compile-time error occurs if P is writeonly.
                If P is not static, the instance expression
                is this.
-------------------------------------------------------------------------   
   
        P = value   The set accessor of the property P in the
                containing class or struct is invoked with
                the argument list (value). A compiletime
                error occurs if P is read-only. If P is not
                static, the instance expression is this.
-------------------------------------------------------------------------   
   
        T.P     The get accessor of the property P in the
                class or struct T is invoked. A compile-time
                error occurs if P is not static or if P is
                write-only.
-------------------------------------------------------------------------   
   
        T.P = value The set accessor of the property P in the
                class or struct T is invoked with the
                argument list (value). A compile-time error
                occurs if P is not static or if P is
                read-only.
-------------------------------------------------------------------------   
   
        e.P     The get accessor of the property P in the
                class, struct, or interface given by the
                type of e is invoked with the instance
                expression e. A compile-time error occurs
                if P is static or if P is write-only.
--------------------------------------------------------------------------  
   
        e.P = value The set accessor of the property P in the
                class, struct, or interface given by the
                type of e is invoked with the instance
                expression e and the argument list (value).
                A compile-time error occurs if P is static
                or if P is read-only.
--------------------------------------------------------------------------  
   
Event access    E += value  The add accessor of the event E in the
                containing class or struct is invoked. If
                E is not static, the instance expression
                is this.
-------------------------------------------------------------------------   
   
        E -= value  The remove accessor of the event E in the
                containing class or struct is invoked. If
                E is not static, the instance expression
                is this.
------------------------------------------------------------------------    
   
        T.E += value    The add accessor of the event E in the
                class or struct T is invoked. A
                compile-time error occurs if E is not
                static.
------------------------------------------------------------------------    
   
        T.E -= value    The remove accessor of the event E in the
                class or struct T is invoked. A
                compile-time error occurs if E is not
                static.
------------------------------------------------------------------------    
   
        e.E += value    The add accessor of the event E in the
                class, struct, or interface given by the
                type of e is invoked with the instance
                expression e. A compile-time error occurs
                if E is static.
------------------------------------------------------------------------    
   
        e.E -= value    The remove accessor of the event E in the
                class, struct, or interface given by the
                type of e is invoked with the instance
                expression e. A compile-time error occurs
                if E is static.
------------------------------------------------------------------------    
   
Indexer     e[x, y]     Overload resolution is applied to select 
access              the best indexer in the class, struct, or
                interface given by the type of e. The get


                accessor of the indexer is invoked with the
                instance expression e and the argument list
                (x, y). A compile-time error occurs if the
                indexer is write-only.
------------------------------------------------------------------------   
        e[x, y] = value Overload resolution is applied to select
                the best indexer in the class, struct, or
                interface given by the type of e. The set
                accessor of the indexer is invoked with
                the instance expression e and the argument
                list (x, y, value). A compile-time error
                occurs if the indexer is read-only.
------------------------------------------------------------------------    
   
Operator    -x      Overload resolution is applied to select 
invocation          the best unary operator in the class or
                struct given by the type of x. The
                selected operator is invoked with the
                argument list (x). 
------------------------------------------------------------------------   
        x + y       Overload resolution is applied to select
                the best binary operator in the classes
                or structs given by the types of x and y.
                The selected operator is invoked with the
                argument list (x, y).  
------------------------------------------------------------------------    
    
Instance    new T(x, y) Overload resolution is applied to select
constructor         the best instance constructor in the class
invocation          or struct T. The instance constructor is
                invoked with the argument list (x, y).