ECMA-334: 10.6 Signatures and overloading

Microsoft .NET Framework, ASP.NET, Visual C# (CSharp, C Sharp, C-Sharp) Developer Training, Visual Studio

C# Language Specification

10. Basic concepts 10.1 Application startup 10.2 Application termination 10.3 Declarations 10.4 Members 10.5 Member access 10.6 Signatures and overloading 10.7 Scopes 10.8 Namespace and type names 10.9 Automatic memory management 10.10 Execution order

© 2006 ECMA International

10.6 Signatures and overloading

Methods, instance constructors, indexers, and operators are characterized by their signatures:

• The signature of a method consists of the name of the method, the number of type parameters, and the type and kind (value, reference, or output) of each of its formal parameters, considered in the order left to right. The signature of a method specifically does not include the return type, parameter names, or type parameter names, nor does it include the params modifier that can be specified for the right-most parameter. When a parameter type includes a type parameter of the method, the ordinal position of the type parameter is used for type equivalence, not the name of the type parameter.

• The signature of an instance constructor consists of the type and kind (value, reference, or output) of each of its formal parameters, considered in the order left to right. The signature of an instance constructor specifically does not include the parameter names or the params modifier that can be specified for the right-most parameter.

• The signature of an indexer consists of the type of each of its formal parameters, considered in the order left to right. The signature of an indexer specifically does not include the element type or parameter names, nor does it include the params modifier that can be specified for the right-most parameter.

• The signature of an operator consists of the name of the operator and the type of each of its formal parameters, considered in the order left to right. The signature of an operator specifically does not include the result type or parameter names.

Signatures are the enabling mechanism for overloading of members in classes, structs, and interfaces:

• Overloading of methods permits a class, struct, or interface to declare multiple methods with the same name, provided their signatures are unique within that class, struct, or interface.

• Overloading of instance constructors permits a class or struct to declare multiple instance constructors, provided their signatures are unique within that class or struct.

• Overloading of indexers permits a class, struct, or interface to declare multiple indexers, provided their signatures are unique within that class, struct, or interface.

• Overloading of operators permits a class or struct to declare multiple operators with the same name, provided their signatures are unique within that class or struct.

Although out and ref parameter modifiers are considered part of a signature, members declared in a single type cannot differ in signature solely by ref and out. A compile-time error occurs if two members are declared in the same type with signatures that would be the same if all parameters in both methods with out modifiers were changed to ref modifiers. For other purposes of signature matching (e.g., hiding or overriding), ref and out are considered part of the signature and do not match each other. [Note: This restriction is to allow C# programs to be easily translated to run on the Common Language Infrastructure (CLI), which does not provide a way to define methods that differ solely in ref and out. end note]

[Example: The following example shows a set of overloaded method declarations along with their signatures.

interface ITest
{
  void F();                  // F()
  void F(int x);             // F(int)
  void F(ref int x);         // F(ref int)
  void F(out int x);         // F(out int) error
  void F(int x, int y);      // F(int, int)
  int F(string s);           // F(string)
  int F(int x);              // F(int) error
  void F(string[] a);        // F(string[])
  void F(params string[] a); // F(string[]) error
  void F<S>(S s);            // F<`0>(`0)
  void F<T>(T t);            // F<`0>(`0) error
  void F<S,T>(S s);          // F<`0,`1>(`0)
  void F<T,S>(S s);          // F<`0,`1>(`1) ok
}

Note that any ref and out parameter modifiers (§17.5.1) are part of a signature. Thus, F(int), F(ref int), and F(out int) are all unique signatures. However, F(ref int) and F(out int) cannot be declared within the same interface because their signatures differ solely by ref and out. Also, note that the return type and the params modifier are not part of a signature, so it is not possible to overload solely based on return type or on the inclusion or exclusion of the params modifier. As such, the declarations of the methods F(int) and F(params string[]) identified above, result in a compile-time error. end example]