ExpresionesExpressions

Una expresión es una secuencia de operadores y operandos.An expression is a sequence of operators and operands. En este capítulo se define la sintaxis, el orden de evaluación de los operandos y operadores y el significado de las expresiones.This chapter defines the syntax, order of evaluation of operands and operators, and meaning of expressions.

Clasificaciones de expresionesExpression classifications

Una expresión se clasifica de las siguientes formas:An expression is classified as one of the following:

• Un valor.A value. Todos los valores tienen un tipo asociado.Every value has an associated type.
• Una variable.A variable. Cada variable tiene un tipo asociado, es decir, el tipo declarado de la variable.Every variable has an associated type, namely the declared type of the variable.
• Espacio de nombres.A namespace. Una expresión con esta clasificación solo puede aparecer como la parte izquierda de un member_access (acceso a miembros).An expression with this classification can only appear as the left hand side of a member_access (Member access). En cualquier otro contexto, una expresión clasificada como un espacio de nombres produce un error en tiempo de compilación.In any other context, an expression classified as a namespace causes a compile-time error.
• Un tipo.A type. Una expresión con esta clasificación solo puede aparecer como el lado izquierdo de un member_access (acceso a miembros) o como un operando para el as operador (el operador as), el is operador (operador is) o el typeof operador (el operador typeof).An expression with this classification can only appear as the left hand side of a member_access (Member access), or as an operand for the as operator (The as operator), the is operator (The is operator), or the typeof operator (The typeof operator). En cualquier otro contexto, una expresión clasificada como un tipo genera un error en tiempo de compilación.In any other context, an expression classified as a type causes a compile-time error.
• Un grupo de métodos, que es un conjunto de métodos sobrecargados que resultan de una búsqueda de miembros (búsqueda de miembros).A method group, which is a set of overloaded methods resulting from a member lookup (Member lookup). Un grupo de métodos puede tener una expresión de instancia asociada y una lista de argumentos de tipo asociada.A method group may have an associated instance expression and an associated type argument list. Cuando se invoca un método de instancia, el resultado de evaluar la expresión de instancia se convierte en la instancia representada por this (este acceso).When an instance method is invoked, the result of evaluating the instance expression becomes the instance represented by this (This access). Se permite un grupo de métodos en un invocation_expression (expresiones de invocación), un delegate_creation_expression (expresiones de creación de delegado) y como el lado izquierdo de un operador is y se puede convertir implícitamente en un tipo de delegado compatible (conversiones de grupo de métodos).A method group is permitted in an invocation_expression (Invocation expressions) , a delegate_creation_expression (Delegate creation expressions) and as the left hand side of an is operator, and can be implicitly converted to a compatible delegate type (Method group conversions). En cualquier otro contexto, una expresión clasificada como grupo de métodos produce un error en tiempo de compilación.In any other context, an expression classified as a method group causes a compile-time error.
• Un literal null.A null literal. Una expresión con esta clasificación se puede convertir implícitamente a un tipo de referencia o a un tipo que acepta valores NULL.An expression with this classification can be implicitly converted to a reference type or nullable type.
• Una función anónima.An anonymous function. Una expresión con esta clasificación se puede convertir implícitamente en un tipo de delegado compatible o un tipo de árbol de expresión.An expression with this classification can be implicitly converted to a compatible delegate type or expression tree type.
• Un acceso de propiedad.A property access. Cada acceso de propiedad tiene un tipo asociado, es decir, el tipo de la propiedad.Every property access has an associated type, namely the type of the property. Además, un acceso de propiedad puede tener una expresión de instancia asociada.Furthermore, a property access may have an associated instance expression. Cuando se invoca un descriptor get set de acceso (el bloque o) de una propiedad de instancia, el resultado de evaluar la expresión de instancia se convierte en la instancia representada por this (este acceso).When an accessor (the get or set block) of an instance property access is invoked, the result of evaluating the instance expression becomes the instance represented by this (This access).
• Un acceso de evento.An event access. Cada acceso a eventos tiene un tipo asociado, es decir, el tipo del evento.Every event access has an associated type, namely the type of the event. Además, un acceso a eventos puede tener una expresión de instancia asociada.Furthermore, an event access may have an associated instance expression. Un acceso a eventos puede aparecer como el operando izquierdo de += los -= operadores y (asignación de eventos).An event access may appear as the left hand operand of the += and -= operators (Event assignment). En cualquier otro contexto, una expresión clasificada como acceso de evento produce un error en tiempo de compilación.In any other context, an expression classified as an event access causes a compile-time error.
• Un acceso de indexador.An indexer access. Cada acceso de indexador tiene un tipo asociado, es decir, el tipo de elemento del indexador.Every indexer access has an associated type, namely the element type of the indexer. Además, un acceso de indexador tiene una expresión de instancia asociada y una lista de argumentos asociada.Furthermore, an indexer access has an associated instance expression and an associated argument list. Cuando se invoca un descriptor get set de acceso (el bloque o) de un acceso de indexador, el resultado de evaluar la expresión de instancia se convierte en la instancia representada por this (este acceso) y el resultado de evaluar la lista de argumentos se convierte en la lista de parámetros de la invocación.When an accessor (the get or set block) of an indexer access is invoked, the result of evaluating the instance expression becomes the instance represented by this (This access), and the result of evaluating the argument list becomes the parameter list of the invocation.
• Nada.Nothing. Esto sucede cuando la expresión es una invocación de un método con un tipo de valor devuelto de void .This occurs when the expression is an invocation of a method with a return type of void. Una expresión clasificada como Nothing solo es válida en el contexto de una statement_expression (instrucciones de expresión).An expression classified as nothing is only valid in the context of a statement_expression (Expression statements).

El resultado final de una expresión nunca es un espacio de nombres, tipo, grupo de métodos o acceso a eventos.The final result of an expression is never a namespace, type, method group, or event access. En su lugar, como se indicó anteriormente, estas categorías de expresiones son construcciones intermedias que solo se permiten en determinados contextos.Rather, as noted above, these categories of expressions are intermediate constructs that are only permitted in certain contexts.

Un acceso de propiedad o de indexador siempre se reclasifica como un valor realizando una invocación del descriptor de acceso get o del descriptor de acceso set.A property access or indexer access is always reclassified as a value by performing an invocation of the get accessor or the set accessor. El descriptor de acceso concreto viene determinado por el contexto de la propiedad o el acceso del indexador: Si el acceso es el destino de una asignación, se invoca al descriptor de acceso set para asignar un nuevo valor (asignación simple).The particular accessor is determined by the context of the property or indexer access: If the access is the target of an assignment, the set accessor is invoked to assign a new value (Simple assignment). De lo contrario, el descriptor de acceso get se invoca para obtener el valor actual (valores de las expresiones).Otherwise, the get accessor is invoked to obtain the current value (Values of expressions).

Valores de las expresionesValues of expressions

En última instancia, la mayoría de las construcciones que implican una expresión requieren que la expresión denote un valor.Most of the constructs that involve an expression ultimately require the expression to denote a value. En tales casos, si la expresión real denota un espacio de nombres, un tipo, un grupo de métodos o nada, se produce un error en tiempo de compilación.In such cases, if the actual expression denotes a namespace, a type, a method group, or nothing, a compile-time error occurs. Sin embargo, si la expresión denota un acceso de propiedad, un acceso a indexador o una variable, el valor de la propiedad, el indexador o la variable se sustituyen implícitamente:However, if the expression denotes a property access, an indexer access, or a variable, the value of the property, indexer, or variable is implicitly substituted:

• El valor de una variable es simplemente el valor almacenado actualmente en la ubicación de almacenamiento identificada por la variable.The value of a variable is simply the value currently stored in the storage location identified by the variable. Una variable se debe considerar definitivamente asignada (asignación definitiva) antes de que se pueda obtener su valor o, de lo contrario, se producirá un error en tiempo de compilación.A variable must be considered definitely assigned (Definite assignment) before its value can be obtained, or otherwise a compile-time error occurs.
• El valor de una expresión de acceso de propiedad se obtiene invocando el descriptor de acceso get de la propiedad.The value of a property access expression is obtained by invoking the get accessor of the property. Si la propiedad no tiene un descriptor de acceso get, se produce un error en tiempo de compilación.If the property has no get accessor, a compile-time error occurs. De lo contrario, se realiza una invocación de miembro de función (comprobación en tiempo de compilación de la resolución dinámica de sobrecarga) y el resultado de la invocación se convierte en el valor de la expresión de acceso de propiedad.Otherwise, a function member invocation (Compile-time checking of dynamic overload resolution) is performed, and the result of the invocation becomes the value of the property access expression.
• El valor de una expresión de acceso de indexador se obtiene al invocar el descriptor de acceso get del indexador.The value of an indexer access expression is obtained by invoking the get accessor of the indexer. Si el indizador no tiene ningún descriptor de acceso get, se produce un error en tiempo de compilación.If the indexer has no get accessor, a compile-time error occurs. De lo contrario, se realiza una invocación de un miembro de función (comprobación en tiempo de compilación de la resolución dinámica de sobrecarga) con la lista de argumentos asociada a la expresión de acceso del indizador y el resultado de la invocación se convierte en el valor de la expresión de acceso del indexador.Otherwise, a function member invocation (Compile-time checking of dynamic overload resolution) is performed with the argument list associated with the indexer access expression, and the result of the invocation becomes the value of the indexer access expression.

Enlaces estáticos y dinámicosStatic and Dynamic Binding

El proceso de determinar el significado de una operación basándose en el tipo o valor de las expresiones constituyentes (argumentos, operandos, receptores) a menudo se conoce como enlace.The process of determining the meaning of an operation based on the type or value of constituent expressions (arguments, operands, receivers) is often referred to as binding. Por ejemplo, el significado de una llamada al método se determina en función del tipo del receptor y de los argumentos.For instance the meaning of a method call is determined based on the type of the receiver and arguments. El significado de un operador se determina en función del tipo de sus operandos.The meaning of an operator is determined based on the type of its operands.

En C#, el significado de una operación se suele determinar en tiempo de compilación, basándose en el tipo en tiempo de compilación de sus expresiones constituyentes.In C# the meaning of an operation is usually determined at compile-time, based on the compile-time type of its constituent expressions. Del mismo modo, si una expresión contiene un error, el compilador detecta el error y lo emite.Likewise, if an expression contains an error, the error is detected and reported by the compiler. Este enfoque se conoce como enlace estático.This approach is known as static binding.

Sin embargo, si una expresión es una expresión dinámica (es decir, tiene el tipo dynamic ), esto indica que cualquier enlace en el que participe debería basarse en su tipo en tiempo de ejecución (es decir, el tipo real del objeto que denota en tiempo de ejecución) en lugar del tipo que tiene en tiempo de compilación.However, if an expression is a dynamic expression (i.e. has the type dynamic) this indicates that any binding that it participates in should be based on its run-time type (i.e. the actual type of the object it denotes at run-time) rather than the type it has at compile-time. Por consiguiente, el enlace de esta operación se aplaza hasta el momento en que se ejecuta la operación durante la ejecución del programa.The binding of such an operation is therefore deferred until the time where the operation is to be executed during the running of the program. Esto se conoce como enlace dinámico.This is referred to as dynamic binding.

Cuando una operación está enlazada dinámicamente, el compilador realiza poca o ninguna comprobación.When an operation is dynamically bound, little or no checking is performed by the compiler. En su lugar, si se produce un error en el enlace en tiempo de ejecución, los errores se registran como excepciones en tiempo de ejecución.Instead if the run-time binding fails, errors are reported as exceptions at run-time.

Las siguientes operaciones en C# están sujetas al enlace:The following operations in C# are subject to binding:

• Acceso a miembros: e.MMember access: e.M
• Invocación de método: e.M(e1, ..., eN)Method invocation: e.M(e1, ..., eN)
• Invocación de delegado:e(e1, ..., eN)Delegate invocation:e(e1, ..., eN)
• Acceso a elementos: e[e1, ..., eN]Element access: e[e1, ..., eN]
• Creación de objetos: new C(e1, ..., eN)Object creation: new C(e1, ..., eN)
• Operadores unarios sobrecargados: + , - , ! , ~ , ++ , -- , true , falseOverloaded unary operators: +, -, !, ~, ++, --, true, false
• Operadores binarios sobrecargados: + , - , * , / ,,, % & && , | , || , ?? , ^ , << , >> , == , != , > , < , >= , <=Overloaded binary operators: +, -, *, /, %, &, &&, |, ||, ??, ^, <<, >>, ==,!=, >, <, >=, <=
• Operadores de asignación: = , += , -= , *= , /= , %= , &= , |= , ^= , <<= , >>=Assignment operators: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
• Conversiones implícitas y explícitasImplicit and explicit conversions

Cuando no hay ninguna expresión dinámica implicada, el valor predeterminado de C# es el enlace estático, lo que significa que los tipos en tiempo de compilación de las expresiones constituyentes se usan en el proceso de selección.When no dynamic expressions are involved, C# defaults to static binding, which means that the compile-time types of constituent expressions are used in the selection process. Sin embargo, cuando una de las expresiones constituyentes de las operaciones enumeradas anteriormente es una expresión dinámica, la operación se enlaza dinámicamente.However, when one of the constituent expressions in the operations listed above is a dynamic expression, the operation is instead dynamically bound.

Tiempo de enlaceBinding-time

El enlace estático se realiza en tiempo de compilación, mientras que el enlace dinámico tiene lugar en tiempo de ejecución.Static binding takes place at compile-time, whereas dynamic binding takes place at run-time. En las secciones siguientes, el término tiempo de enlace hace referencia a un tiempo de compilación o a un tiempo de ejecución, en función de cuándo tenga lugar el enlace.In the following sections, the term binding-time refers to either compile-time or run-time, depending on when the binding takes place.

En el ejemplo siguiente se muestran las nociones de enlace estático y dinámico y del tiempo de enlace:The following example illustrates the notions of static and dynamic binding and of binding-time:

object  o = 5;
dynamic d = 5;

Console.WriteLine(5);  // static  binding to Console.WriteLine(int)
Console.WriteLine(o);  // static  binding to Console.WriteLine(object)
Console.WriteLine(d);  // dynamic binding to Console.WriteLine(int)

Las dos primeras llamadas se enlazan estáticamente: la sobrecarga de Console.WriteLine se selecciona basándose en el tipo en tiempo de compilación de su argumento.The first two calls are statically bound: the overload of Console.WriteLine is picked based on the compile-time type of their argument. Por lo tanto, el tiempo de enlace es el tiempo de compilación.Thus, the binding-time is compile-time.

La tercera llamada está enlazada dinámicamente: la sobrecarga de Console.WriteLine se selecciona basándose en el tipo en tiempo de ejecución de su argumento.The third call is dynamically bound: the overload of Console.WriteLine is picked based on the run-time type of its argument. Esto sucede porque el argumento es una expresión dinámica: su tipo en tiempo de compilación es dynamic .This happens because the argument is a dynamic expression -- its compile-time type is dynamic. Por lo tanto, el tiempo de enlace para la tercera llamada es en tiempo de ejecución.Thus, the binding-time for the third call is run-time.

Enlace dinámicoDynamic binding

El propósito de los enlaces dinámicos es permitir que los programas de C# interactúen con objetos dinámicos, es decir, los objetos que no siguen las reglas normales del sistema de tipos de c#.The purpose of dynamic binding is to allow C# programs to interact with dynamic objects, i.e. objects that do not follow the normal rules of the C# type system. Los objetos dinámicos pueden ser objetos de otros lenguajes de programación con distintos sistemas de tipos, o bien pueden ser objetos que se configuran mediante programación para implementar su propia semántica de enlace para diferentes operaciones.Dynamic objects may be objects from other programming languages with different types systems, or they may be objects that are programmatically setup to implement their own binding semantics for different operations.

El mecanismo por el que un objeto dinámico implementa su propia semántica es la implementación definida.The mechanism by which a dynamic object implements its own semantics is implementation defined. Una interfaz determinada, que se ha definido de nuevo en la implementación, se implementa mediante objetos dinámicos para indicar al tiempo de ejecución de C# que tienen una semántica especial.A given interface -- again implementation defined -- is implemented by dynamic objects to signal to the C# run-time that they have special semantics. Por lo tanto, cada vez que las operaciones en un objeto dinámico se enlazan dinámicamente, su propia semántica de enlace, en lugar de las de C# tal como se especifica en este documento, asumen el control.Thus, whenever operations on a dynamic object are dynamically bound, their own binding semantics, rather than those of C# as specified in this document, take over.

Aunque el propósito del enlace dinámico es permitir la interoperación con objetos dinámicos, C# permite el enlace dinámico en todos los objetos, tanto si son dinámicos como si no.While the purpose of dynamic binding is to allow interoperation with dynamic objects, C# allows dynamic binding on all objects, whether they are dynamic or not. Esto permite una integración más fluida de los objetos dinámicos, ya que los resultados de las operaciones en ellos pueden no ser objetos dinámicos, pero siguen siendo un tipo desconocido para el programador en tiempo de compilación.This allows for a smoother integration of dynamic objects, as the results of operations on them may not themselves be dynamic objects, but are still of a type unknown to the programmer at compile-time. Además, el enlace dinámico puede ayudar a eliminar el código basado en la reflexión propenso a errores, incluso cuando ningún objeto implicado sea de objetos dinámicos.Also dynamic binding can help eliminate error-prone reflection-based code even when no objects involved are dynamic objects.

En las secciones siguientes se describe para cada construcción del lenguaje exactamente cuando se aplica el enlace dinámico, qué comprobación del tiempo de compilación se aplica, en caso de que se aplique, y cuál es el resultado en tiempo de compilación y la clasificación de la expresión.The following sections describe for each construct in the language exactly when dynamic binding is applied, what compile time checking -- if any -- is applied, and what the compile-time result and expression classification is.

Tipos de expresiones constituyentesTypes of constituent expressions

Cuando una operación se enlaza estáticamente, el tipo de una expresión constituyente (por ejemplo, un receptor, un argumento, un índice o un operando) siempre se considera el tipo en tiempo de compilación de esa expresión.When an operation is statically bound, the type of a constituent expression (e.g. a receiver, an argument, an index or an operand) is always considered to be the compile-time type of that expression.

Cuando una operación se enlaza de forma dinámica, el tipo de una expresión constituyente se determina de maneras diferentes en función del tipo en tiempo de compilación de la expresión constituyente:When an operation is dynamically bound, the type of a constituent expression is determined in different ways depending on the compile-time type of the constituent expression:

• Se considera que una expresión constitutiva del tipo en tiempo de compilación dynamic tiene el tipo del valor real al que se evalúa la expresión en tiempo de ejecución.A constituent expression of compile-time type dynamic is considered to have the type of the actual value that the expression evaluates to at runtime
• Expresión constituyente cuyo tipo en tiempo de compilación es un parámetro de tipo se considera que tiene el tipo al que está enlazado el parámetro de tipo en tiempo de ejecución.A constituent expression whose compile-time type is a type parameter is considered to have the type which the type parameter is bound to at runtime
• De lo contrario, se considera que la expresión Constituyente tiene su tipo en tiempo de compilación.Otherwise the constituent expression is considered to have its compile-time type.

OperadoresOperators

Las expresiones se construyen a partir de los operadores*operandos _ y.Expressions are constructed from operands _ and _operators*_. Los operadores de una expresión indican qué operaciones se aplican a los operandos.The operators of an expression indicate which operations to apply to the operands. Ejemplos de operadores incluyen +, -, _, / y new.Examples of operators include +, -, _, /, and new. Algunos ejemplos de operandos son literales, campos, variables locales y expresiones.Examples of operands include literals, fields, local variables, and expressions.

Hay tres tipos de operadores:There are three kinds of operators:

• Operadores unarios.Unary operators. Los operadores unarios toman un operando y usan la notación de prefijo (como --x ) o la notación de postfijo (como x++ ).The unary operators take one operand and use either prefix notation (such as --x) or postfix notation (such as x++).
• Operadores binarios.Binary operators. Los operadores binarios toman dos operandos y todos usan la notación infija (como x + y ).The binary operators take two operands and all use infix notation (such as x + y).
• Operador ternario.Ternary operator. Solo un operador ternario, ?: , existe; toma tres operandos y usa la notación de infijo ( c ? x : y ).Only one ternary operator, ?:, exists; it takes three operands and uses infix notation (c ? x : y).

El orden de evaluación de los operadores de una expresión viene determinado por la precedencia _ and _ asociativity de los operadores (precedencia y asociatividad del operador).The order of evaluation of operators in an expression is determined by the precedence _ and _ associativity of the operators (Operator precedence and associativity).

Los operandos de una expresión se evalúan de izquierda a derecha.Operands in an expression are evaluated from left to right. Por ejemplo, en F(i) + G(i++) * H(i) , se llama al método con F el valor anterior de i , a continuación, se llama al método G con el valor anterior de i , y, por último, H se llama al método con el nuevo valor de i .For example, in F(i) + G(i++) * H(i), method F is called using the old value of i, then method G is called with the old value of i, and, finally, method H is called with the new value of i. Esto es independiente de la prioridad de operador y no está relacionada con ella.This is separate from and unrelated to operator precedence.

Algunos operadores se pueden sobrecargar.Certain operators can be overloaded. La sobrecarga de operadores permite especificar implementaciones de operador definidas por el usuario para las operaciones donde uno o ambos operandos son de una clase definida por el usuario o un tipo de estructura (sobrecarga de operadores).Operator overloading permits user-defined operator implementations to be specified for operations where one or both of the operands are of a user-defined class or struct type (Operator overloading).

Prioridad y asociatividad de los operadoresOperator precedence and associativity

Cuando una expresión contiene varios operadores, el *precedencia _ de los operadores controla el orden en el que se evalúan los operadores individuales.When an expression contains multiple operators, the *precedence _ of the operators controls the order in which the individual operators are evaluated. Por ejemplo, la expresión x + y _ z se evalúa como x + (y * z) porque el operador * tiene mayor precedencia que el operador binario +.For example, the expression x + y _ z is evaluated as x + (y * z) because the * operator has higher precedence than the binary + operator. La precedencia de un operador se establece mediante la definición de su producción gramatical asociada.The precedence of an operator is established by the definition of its associated grammar production. Por ejemplo, un additive_expression se compone de una secuencia de multiplicative_expression s separadas + por - operadores or, lo que permite que los operadores + y tengan - menor prioridad que los * / operadores, y % .For example, an additive_expression consists of a sequence of multiplicative_expression s separated by + or - operators, thus giving the + and - operators lower precedence than the *, /, and % operators.

En la tabla siguiente se resumen todos los operadores en orden de prioridad, de mayor a menor:The following table summarizes all operators in order of precedence from highest to lowest:

Cuando un operando se encuentra entre dos operadores con la misma precedencia, la asociatividad de los operadores controla el orden en que se realizan las operaciones:When an operand occurs between two operators with the same precedence, the associativity of the operators controls the order in which the operations are performed:

• Excepto en el caso de los operadores de asignación y el operador de uso combinado de NULL, todos los operadores binarios son asociativos a la izquierda, lo que significa que las operaciones se realizan de izquierda a derecha.Except for the assignment operators and the null coalescing operator, all binary operators are left-associative, meaning that operations are performed from left to right. Por ejemplo, x + y + z se evalúa como (x + y) + z.For example, x + y + z is evaluated as (x + y) + z.
• Los operadores de asignación, el operador de uso combinado de NULL y el operador condicional ( ?: ) son asociativos a la derecha, lo que significa que las operaciones se realizan de derecha a izquierda.The assignment operators, the null coalescing operator and the conditional operator (?:) are right-associative, meaning that operations are performed from right to left. Por ejemplo, x = y = z se evalúa como x = (y = z).For example, x = y = z is evaluated as x = (y = z).

La precedencia y la asociatividad pueden controlarse mediante paréntesis.Precedence and associativity can be controlled using parentheses. Por ejemplo, x + y * z primero multiplica y por z y luego suma el resultado a x, pero (x + y) * z primero suma x y y y luego multiplica el resultado por z.For example, x + y * z first multiplies y by z and then adds the result to x, but (x + y) * z first adds x and y and then multiplies the result by z.

Sobrecarga de operadoresOperator overloading

Todos los operadores unarios y binarios tienen implementaciones predefinidas que están disponibles automáticamente en cualquier expresión.All unary and binary operators have predefined implementations that are automatically available in any expression. Además de las implementaciones predefinidas, las implementaciones definidas por el usuario se pueden introducir incluyendo operator declaraciones en clases y Structs (operadores).In addition to the predefined implementations, user-defined implementations can be introduced by including operator declarations in classes and structs (Operators). Las implementaciones de operador definidas por el usuario siempre tienen prioridad sobre las implementaciones de operadores predefinidas: solo cuando no existan implementaciones de operadores definidos por el usuario aplicables, se tendrán en cuenta las implementaciones de operadores predefinidas, como se describe en resolución de sobrecargas de operador unario y resolución de sobrecarga de operadores binarios.User-defined operator implementations always take precedence over predefined operator implementations: Only when no applicable user-defined operator implementations exist will the predefined operator implementations be considered, as described in Unary operator overload resolution and Binary operator overload resolution.

Los operadores unarios sobrecargables son:The overloadable unary operators are:

+   -   !   ~   ++   --   true   false

Aunque true y false no se utilizan explícitamente en expresiones (y, por consiguiente, no se incluyen en la tabla de precedencia en la precedencia y asociatividadde los operadores), se consideran operadores porque se invocan en varios contextos de expresión: Expresiones booleanas (Expresiones booleanas) y expresiones que implican al operador condicional (operador condicional) y operadores lógicos condicionales (operadores lógicos condicionales)Although true and false are not used explicitly in expressions (and therefore are not included in the precedence table in Operator precedence and associativity), they are considered operators because they are invoked in several expression contexts: boolean expressions (Boolean expressions) and expressions involving the conditional (Conditional operator), and conditional logical operators (Conditional logical operators).

Los operadores binarios sobrecargables son:The overloadable binary operators are:

+   -   *   /   %   &   |   ^   <<   >>   ==   !=   >   <   >=   <=

Solo se pueden sobrecargar los operadores enumerados anteriormente.Only the operators listed above can be overloaded. En concreto, no es posible sobrecargar el acceso a miembros, la invocación de métodos o los = && operadores,,,,,,,,,,, || ?? ?: => checked unchecked new typeof default as y is .In particular, it is not possible to overload member access, method invocation, or the =, &&, ||, ??, ?:, =>, checked, unchecked, new, typeof, default, as, and is operators.

Cuando se sobrecarga un operador binario, el operador de asignación correspondiente, si lo hay, también se sobrecarga de modo implícito.When a binary operator is overloaded, the corresponding assignment operator, if any, is also implicitly overloaded. Por ejemplo, una sobrecarga del operador * también es una sobrecarga del operador *= .For example, an overload of operator * is also an overload of operator *=. Esto se describe con más detalle en asignación compuesta.This is described further in Compound assignment. Tenga en cuenta que el operador de asignación ( = ) no se puede sobrecargar.Note that the assignment operator itself (=) cannot be overloaded. Una asignación siempre realiza una copia simple de bits de un valor en una variable.An assignment always performs a simple bit-wise copy of a value into a variable.

Las operaciones de conversión, como (T)x , se sobrecargan proporcionando conversiones definidas por el usuario (conversiones definidas por el usuario).Cast operations, such as (T)x, are overloaded by providing user-defined conversions (User-defined conversions).

El acceso a elementos, como a[x] , no se considera un operador sobrecargable.Element access, such as a[x], is not considered an overloadable operator. En su lugar, se admite la indexación definida por el usuario a través de indexadores (indizadores).Instead, user-defined indexing is supported through indexers (Indexers).

En las expresiones, se hace referencia a los operadores mediante la notación de operador y, en las declaraciones, se hace referencia a los operadores mediante la notación funcional.In expressions, operators are referenced using operator notation, and in declarations, operators are referenced using functional notation. En la tabla siguiente se muestra la relación entre el operador y las notaciones funcionales para los operadores unarios y binarios.The following table shows the relationship between operator and functional notations for unary and binary operators. En la primera entrada, OP denota cualquier operador de prefijo unario sobrecargable.In the first entry, op denotes any overloadable unary prefix operator. En la segunda entrada, OP denota los operadores y postfijo unarios ++ -- .In the second entry, op denotes the unary postfix ++ and -- operators. En la tercera entrada, OP denota cualquier operador binario sobrecargable.In the third entry, op denotes any overloadable binary operator.

Las declaraciones de operador definidas por el usuario siempre requieren que al menos uno de los parámetros sea del tipo de clase o estructura que contiene la declaración de operador.User-defined operator declarations always require at least one of the parameters to be of the class or struct type that contains the operator declaration. Por lo tanto, no es posible que un operador definido por el usuario tenga la misma firma que un operador predefinido.Thus, it is not possible for a user-defined operator to have the same signature as a predefined operator.

Las declaraciones de operador definidas por el usuario no pueden modificar la sintaxis, la precedencia o la asociatividad de un operador.User-defined operator declarations cannot modify the syntax, precedence, or associativity of an operator. Por ejemplo, el / operador siempre es un operador binario, siempre tiene el nivel de prioridad especificado en precedencia y asociatividadde los operadores y siempre es asociativo a la izquierda.For example, the / operator is always a binary operator, always has the precedence level specified in Operator precedence and associativity, and is always left-associative.

Aunque es posible que un operador definido por el usuario realice cualquier cálculo, se desaconsejan las implementaciones que generan resultados distintos de los que se esperaban de forma intuitiva.While it is possible for a user-defined operator to perform any computation it pleases, implementations that produce results other than those that are intuitively expected are strongly discouraged. Por ejemplo, una implementación de operator == debería comparar los dos operandos para determinar si son iguales y devolver un bool resultado adecuado.For example, an implementation of operator == should compare the two operands for equality and return an appropriate bool result.

Las descripciones de operadores individuales en expresiones primarias a través de operadores lógicos condicionales especifican las implementaciones predefinidas de los operadores y cualquier regla adicional que se aplique a cada operador.The descriptions of individual operators in Primary expressions through Conditional logical operators specify the predefined implementations of the operators and any additional rules that apply to each operator. En las descripciones se usa la *resolución de sobrecargas del operador unario***, la _resolución de sobrecarga del operador binario*, y _ valores de promoción *, las definiciones de que se encuentran en las secciones siguientes.The descriptions make use of the terms unary operator overload resolution _, _binary operator overload resolution*, and _*numeric promotion**, definitions of which are found in the following sections.

Resolución de sobrecarga del operador unarioUnary operator overload resolution

Una operación con el formato op x o x op , donde op es un operador unario sobrecargable y x es una expresión de tipo X , se procesa de la siguiente manera:An operation of the form op x or x op, where op is an overloadable unary operator, and x is an expression of type X, is processed as follows:

• El conjunto de operadores candidatos definidos por el usuario que proporciona X para la operación operator op(x) se determina mediante las reglas de los operadores candidatos definidospor el usuario.The set of candidate user-defined operators provided by X for the operation operator op(x) is determined using the rules of Candidate user-defined operators.
• Si el conjunto de operadores definidos por el usuario candidatos no está vacío, se convierte en el conjunto de operadores candidatos para la operación.If the set of candidate user-defined operators is not empty, then this becomes the set of candidate operators for the operation. De lo contrario, las implementaciones unarias predefinidas operator op , incluidas sus formas de elevación, se convierten en el conjunto de operadores candidatos para la operación.Otherwise, the predefined unary operator op implementations, including their lifted forms, become the set of candidate operators for the operation. Las implementaciones predefinidas de un operador determinado se especifican en la descripción del operador (expresiones primarias y operadores unarios).The predefined implementations of a given operator are specified in the description of the operator (Primary expressions and Unary operators).
• Las reglas de resolución de sobrecarga de la resolución de sobrecarga se aplican al conjunto de operadores candidatos para seleccionar el mejor operador con respecto a la lista de argumentos (x) , y este operador se convierte en el resultado del proceso de resolución de sobrecarga.The overload resolution rules of Overload resolution are applied to the set of candidate operators to select the best operator with respect to the argument list (x), and this operator becomes the result of the overload resolution process. Si la resolución de sobrecarga no selecciona un solo operador mejor, se produce un error en tiempo de enlace.If overload resolution fails to select a single best operator, a binding-time error occurs.

Resolución de sobrecarga del operador binarioBinary operator overload resolution

Una operación con el formato x op y , donde op es un operador binario sobrecargable, x es una expresión de tipo X y y es una expresión de tipo Y , que se procesa de la siguiente manera:An operation of the form x op y, where op is an overloadable binary operator, x is an expression of type X, and y is an expression of type Y, is processed as follows:

• Se determina el conjunto de operadores candidatos definidos por el usuario que proporciona X y Y para la operación operator op(x,y) .The set of candidate user-defined operators provided by X and Y for the operation operator op(x,y) is determined. El conjunto consta de la Unión de los operadores candidatos proporcionados por X y los operadores candidatos proporcionados por, cada uno de los cuales se Y determina mediante las reglas de los operadores candidatos definidospor el usuario.The set consists of the union of the candidate operators provided by X and the candidate operators provided by Y, each determined using the rules of Candidate user-defined operators. Si X y Y son del mismo tipo, o si X y Y se derivan de un tipo base común, los operadores candidatos compartidos solo se producen en el conjunto combinado una vez.If X and Y are the same type, or if X and Y are derived from a common base type, then shared candidate operators only occur in the combined set once.
• Si el conjunto de operadores definidos por el usuario candidatos no está vacío, se convierte en el conjunto de operadores candidatos para la operación.If the set of candidate user-defined operators is not empty, then this becomes the set of candidate operators for the operation. De lo contrario, las implementaciones binarias predefinidas operator op , incluidas sus formas de elevación, se convierten en el conjunto de operadores candidatos para la operación.Otherwise, the predefined binary operator op implementations, including their lifted forms, become the set of candidate operators for the operation. Las implementaciones predefinidas de un operador determinado se especifican en la descripción del operador (operadores aritméticos a través de operadores lógicos condicionales).The predefined implementations of a given operator are specified in the description of the operator (Arithmetic operators through Conditional logical operators). En el caso de los operadores de enumeración y delegado predefinidos, los únicos operadores considerados son los definidos por un tipo de delegado o de enumeración que es el tipo en tiempo de enlace de uno de los operandos.For predefined enum and delegate operators, the only operators considered are those defined by an enum or delegate type that is the binding-time type of one of the operands.
• Las reglas de resolución de sobrecarga de la resolución de sobrecarga se aplican al conjunto de operadores candidatos para seleccionar el mejor operador con respecto a la lista de argumentos (x,y) , y este operador se convierte en el resultado del proceso de resolución de sobrecarga.The overload resolution rules of Overload resolution are applied to the set of candidate operators to select the best operator with respect to the argument list (x,y), and this operator becomes the result of the overload resolution process. Si la resolución de sobrecarga no selecciona un solo operador mejor, se produce un error en tiempo de enlace.If overload resolution fails to select a single best operator, a binding-time error occurs.

Operadores candidatos definidos por el usuarioCandidate user-defined operators

Dado un tipo T y una operación operator op(A) , donde op es un operador sobrecargable y A es una lista de argumentos, el conjunto de operadores definidos por el usuario candidatos que proporciona T for operator op(A) se determina de la manera siguiente:Given a type T and an operation operator op(A), where op is an overloadable operator and A is an argument list, the set of candidate user-defined operators provided by T for operator op(A) is determined as follows:

• Determine el tipo T0 .Determine the type T0. Si T es un tipo que acepta valores NULL, T0 es su tipo subyacente, de lo contrario, T0 es igual a T .If T is a nullable type, T0 is its underlying type, otherwise T0 is equal to T.
• Para todas las operator op declaraciones de T0 y todas las formas de elevación de estos operadores, si al menos un operador es aplicable (miembro de función aplicable) con respecto a la lista de argumentos A , el conjunto de operadores candidatos está formado por todos los operadores aplicables en T0 .For all operator op declarations in T0 and all lifted forms of such operators, if at least one operator is applicable (Applicable function member) with respect to the argument list A, then the set of candidate operators consists of all such applicable operators in T0.
• De lo contrario, si T0 es object , el conjunto de operadores candidatos está vacío.Otherwise, if T0 is object, the set of candidate operators is empty.
• De lo contrario, el conjunto de operadores candidatos proporcionado por T0 es el conjunto de operadores candidatos proporcionado por la clase base directa de T0 , o la clase base efectiva de T0 si T0 es un parámetro de tipo.Otherwise, the set of candidate operators provided by T0 is the set of candidate operators provided by the direct base class of T0, or the effective base class of T0 if T0 is a type parameter.

Promociones numéricasNumeric promotions

La promoción numérica consiste en realizar automáticamente determinadas conversiones implícitas de los operandos de los operadores binarios y unarios predefinidos.Numeric promotion consists of automatically performing certain implicit conversions of the operands of the predefined unary and binary numeric operators. La promoción numérica no es un mecanismo distinto, sino un efecto de aplicar la resolución de sobrecarga a los operadores predefinidos.Numeric promotion is not a distinct mechanism, but rather an effect of applying overload resolution to the predefined operators. La promoción numérica específicamente no afecta a la evaluación de operadores definidos por el usuario, aunque se pueden implementar operadores definidos por el usuario para mostrar efectos similares.Numeric promotion specifically does not affect evaluation of user-defined operators, although user-defined operators can be implemented to exhibit similar effects.

Como ejemplo de promoción numérica, tenga en cuenta las implementaciones predefinidas del * operador binario:As an example of numeric promotion, consider the predefined implementations of the binary * operator:

int operator *(int x, int y);
uint operator *(uint x, uint y);
long operator *(long x, long y);
ulong operator *(ulong x, ulong y);
float operator *(float x, float y);
double operator *(double x, double y);
decimal operator *(decimal x, decimal y);

Cuando se aplican las reglas de resolución de sobrecarga (resolución de sobrecarga) a este conjunto de operadores, el efecto es seleccionar el primero de los operadores para los que existen conversiones implícitas desde los tipos de operando.When overload resolution rules (Overload resolution) are applied to this set of operators, the effect is to select the first of the operators for which implicit conversions exist from the operand types. Por ejemplo, para la operación b * s , donde b es byte y s es short , la resolución de sobrecarga selecciona operator *(int,int) como el mejor operador.For example, for the operation b * s, where b is a byte and s is a short, overload resolution selects operator *(int,int) as the best operator. Por lo tanto, el efecto es que b y s se convierten en y int el tipo del resultado es int .Thus, the effect is that b and s are converted to int, and the type of the result is int. Del mismo modo, para la operación i * d , donde i es int y d es double , la resolución de sobrecarga selecciona operator *(double,double) como el mejor operador.Likewise, for the operation i * d, where i is an int and d is a double, overload resolution selects operator *(double,double) as the best operator.

Promociones numéricas unariasUnary numeric promotions

La promoción numérica unaria se produce para los operandos de los + - operadores unarios predefinidos, y ~ .Unary numeric promotion occurs for the operands of the predefined +, -, and ~ unary operators. La promoción numérica unaria simplemente consiste en convertir operandos de tipo sbyte , byte , short , ushort o char en tipo int .Unary numeric promotion simply consists of converting operands of type sbyte, byte, short, ushort, or char to type int. Además, para el operador unario - , la promoción numérica unaria convierte operandos de tipo uint al tipo long .Additionally, for the unary - operator, unary numeric promotion converts operands of type uint to type long.

Promociones numéricas binariasBinary numeric promotions

La promoción numérica binaria se produce para los operandos de los + - * / % & | ^ == != > < >= <= operadores binarios predefinidos,,,,,,,,,,,, y.Binary numeric promotion occurs for the operands of the predefined +, -, *, /, %, &, |, ^, ==, !=, >, <, >=, and <= binary operators. La promoción numérica binaria convierte implícitamente ambos operandos en un tipo común que, en el caso de los operadores no relacionales, también se convierte en el tipo de resultado de la operación.Binary numeric promotion implicitly converts both operands to a common type which, in case of the non-relational operators, also becomes the result type of the operation. La promoción numérica binaria consiste en aplicar las siguientes reglas, en el orden en que aparecen aquí:Binary numeric promotion consists of applying the following rules, in the order they appear here:

• Si alguno de los operandos es de tipo decimal , el otro operando se convierte al tipo decimal , o se produce un error en tiempo de enlace si el otro operando es de tipo float o double .If either operand is of type decimal, the other operand is converted to type decimal, or a binding-time error occurs if the other operand is of type float or double.
• De lo contrario, si alguno de los operandos es de tipo double , el otro operando se convierte al tipo double .Otherwise, if either operand is of type double, the other operand is converted to type double.
• De lo contrario, si alguno de los operandos es de tipo float , el otro operando se convierte al tipo float .Otherwise, if either operand is of type float, the other operand is converted to type float.
• De lo contrario, si alguno de los operandos es de tipo ulong , el otro operando se convierte al tipo ulong , o se produce un error en tiempo de enlace si el otro operando es de tipo sbyte , short , int o long .Otherwise, if either operand is of type ulong, the other operand is converted to type ulong, or a binding-time error occurs if the other operand is of type sbyte, short, int, or long.
• De lo contrario, si alguno de los operandos es de tipo long , el otro operando se convierte al tipo long .Otherwise, if either operand is of type long, the other operand is converted to type long.
• De lo contrario, si alguno de los operandos es de tipo uint y el otro operando es de tipo sbyte , short o int , ambos operandos se convierten al tipo long .Otherwise, if either operand is of type uint and the other operand is of type sbyte, short, or int, both operands are converted to type long.
• De lo contrario, si alguno de los operandos es de tipo uint , el otro operando se convierte al tipo uint .Otherwise, if either operand is of type uint, the other operand is converted to type uint.
• De lo contrario, ambos operandos se convierten al tipo int .Otherwise, both operands are converted to type int.

Tenga en cuenta que la primera regla no permite ninguna operación que mezcle el decimal tipo con double los float tipos y.Note that the first rule disallows any operations that mix the decimal type with the double and float types. La regla sigue el hecho de que no hay conversiones implícitas entre el decimal tipo y los double float tipos y.The rule follows from the fact that there are no implicit conversions between the decimal type and the double and float types.

Tenga en cuenta también que no es posible que un operando sea de tipo ulong cuando el otro operando es de un tipo entero con signo.Also note that it is not possible for an operand to be of type ulong when the other operand is of a signed integral type. La razón es que no existe ningún tipo entero que pueda representar el intervalo completo de ulong , así como los tipos enteros con signo.The reason is that no integral type exists that can represent the full range of ulong as well as the signed integral types.

En los dos casos anteriores, se puede usar una expresión de conversión para convertir explícitamente un operando en un tipo que sea compatible con el otro operando.In both of the above cases, a cast expression can be used to explicitly convert one operand to a type that is compatible with the other operand.

En el ejemploIn the example

decimal AddPercent(decimal x, double percent) {
    return x * (1.0 + percent / 100.0);
}

se produce un error en tiempo de enlace porque decimal no se puede multiplicar por double .a binding-time error occurs because a decimal cannot be multiplied by a double. El error se resuelve convirtiendo explícitamente el segundo operando en decimal , como se indica a continuación:The error is resolved by explicitly converting the second operand to decimal, as follows:

decimal AddPercent(decimal x, double percent) {
    return x * (decimal)(1.0 + percent / 100.0);
}

Operadores de elevaciónLifted operators

Los operadores de elevación permiten a los operadores predefinidos y definidos por el usuario que operan en tipos de valor que no aceptan valores NULL usarse también con formas que aceptan valores NULL de esos tipos.Lifted operators permit predefined and user-defined operators that operate on non-nullable value types to also be used with nullable forms of those types. Los operadores de elevación se construyen a partir de operadores predefinidos y definidos por el usuario que cumplen ciertos requisitos, como se describe a continuación:Lifted operators are constructed from predefined and user-defined operators that meet certain requirements, as described in the following:

• Para los operadores unariosFor the unary operators

  +  ++  -  --  !  ~
  

  existe una forma de elevación de un operador si el operando y los tipos de resultado son tipos de valor que no aceptan valores NULL.a lifted form of an operator exists if the operand and result types are both non-nullable value types. La forma de elevación se construye agregando un único ? modificador al operando y a los tipos de resultado.The lifted form is constructed by adding a single ? modifier to the operand and result types. El operador de elevación genera un valor NULL si el operando es NULL.The lifted operator produces a null value if the operand is null. De lo contrario, el operador de elevación desencapsula el operando, aplica el operador subyacente y ajusta el resultado.Otherwise, the lifted operator unwraps the operand, applies the underlying operator, and wraps the result.

• Para los operadores binariosFor the binary operators

  +  -  *  /  %  &  |  ^  <<  >>
  

  existe una forma de elevación de un operador si el operando y los tipos de resultado son todos tipos de valor que no aceptan valores NULL.a lifted form of an operator exists if the operand and result types are all non-nullable value types. La forma de elevación se construye agregando un único ? modificador a cada operando y tipo de resultado.The lifted form is constructed by adding a single ? modifier to each operand and result type. El operador de elevación genera un valor NULL si uno o los dos operandos son NULL (una excepción son los & | operadores y del bool? tipo, como se describe en operadores lógicos booleanos).The lifted operator produces a null value if one or both operands are null (an exception being the & and | operators of the bool? type, as described in Boolean logical operators). De lo contrario, el operador de elevación desencapsula los operandos, aplica el operador subyacente y ajusta el resultado.Otherwise, the lifted operator unwraps the operands, applies the underlying operator, and wraps the result.

• Para los operadores de igualdadFor the equality operators

  ==  !=
  

  existe una forma de elevación de un operador si los tipos de operando son tipos de valor que no aceptan valores NULL y si el tipo de resultado es bool .a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is bool. La forma de elevación se construye agregando un único ? modificador a cada tipo de operando.The lifted form is constructed by adding a single ? modifier to each operand type. El operador de elevación considera que dos valores NULL son iguales y un valor NULL es distinto de cualquier valor distinto de NULL.The lifted operator considers two null values equal, and a null value unequal to any non-null value. Si ambos operandos no son NULL, el operador de elevación desencapsula los operandos y aplica el operador subyacente para generar el bool resultado.If both operands are non-null, the lifted operator unwraps the operands and applies the underlying operator to produce the bool result.

• Para los operadores relacionalesFor the relational operators

  <  >  <=  >=
  

  existe una forma de elevación de un operador si los tipos de operando son tipos de valor que no aceptan valores NULL y si el tipo de resultado es bool .a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is bool. La forma de elevación se construye agregando un único ? modificador a cada tipo de operando.The lifted form is constructed by adding a single ? modifier to each operand type. El operador de elevación produce el valor false si uno o los dos operandos son NULL.The lifted operator produces the value false if one or both operands are null. De lo contrario, el operador de elevación desencapsula los operandos y aplica el operador subyacente para generar el bool resultado.Otherwise, the lifted operator unwraps the operands and applies the underlying operator to produce the bool result.

Búsqueda de miembrosMember lookup

Una búsqueda de miembros es el proceso por el que se determina el significado de un nombre en el contexto de un tipo.A member lookup is the process whereby the meaning of a name in the context of a type is determined. Una búsqueda de miembros se puede producir como parte de la evaluación de una simple_name (nombres simples) o un member_access (acceso a miembros) en una expresión.A member lookup can occur as part of evaluating a simple_name (Simple names) or a member_access (Member access) in an expression. Si el simple_name o member_access se produce como primary_expression de un invocation_expression (invocaciones de método), se dice que el miembro se invoca.If the simple_name or member_access occurs as the primary_expression of an invocation_expression (Method invocations), the member is said to be invoked.

Si un miembro es un método o un evento, o si es una constante, un campo o una propiedad de un tipo de delegado (delegados) o del tipo dynamic (el tipo dinámico), se dice que el miembro es invocable.If a member is a method or event, or if it is a constant, field or property of either a delegate type (Delegates) or the type dynamic (The dynamic type), then the member is said to be invocable.

La búsqueda de miembros considera no solo el nombre de un miembro, sino también el número de parámetros de tipo que tiene el miembro y si el miembro es accesible.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. En lo que respecta a la búsqueda de miembros, los métodos genéricos y los tipos genéricos anidados tienen el número de parámetros de tipo indicado en sus declaraciones respectivas y todos los demás miembros tienen parámetros de tipo cero.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.

Una búsqueda de miembro de un nombre  N con K   parámetros de tipo en un tipo  T se procesa de la siguiente manera:A member lookup of a name N with K type parameters in a type T is processed as follows:

• En primer lugar, se determina un conjunto de miembros accesibles denominados  N :First, a set of accessible members named N is determined:
  • Si T es un parámetro de tipo, el conjunto es la Unión de los conjuntos de miembros accesibles denominados  N en cada uno de los tipos especificados como restricción principal o restricción secundaria (restricciones de parámetro de tipo) para  T , junto con el conjunto de miembros accesibles denominados  N en object .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 (Type parameter constraints) for T, along with the set of accessible members named N in object.
  • De lo contrario, el conjunto se compone de todos los miembros accesibles (acceso a miembros) denominados  N en  T , incluidos los miembros heredados y los miembros accesibles denominados  N en object .Otherwise, the set consists of all accessible (Member access) members named N in T, including inherited members and the accessible members named N in object. Si T es un tipo construido, el conjunto de miembros se obtiene sustituyendo los argumentos de tipo tal y como se describe en miembros de tipos construidos.If T is a constructed type, the set of members is obtained by substituting type arguments as described in Members of constructed types. Los miembros que incluyen un override modificador se excluyen del conjunto.Members that include an override modifier are excluded from the set.
• Después, si K es cero, se quitan todos los tipos anidados cuyas declaraciones incluyen parámetros de tipo.Next, if K is zero, all nested types whose declarations include type parameters are removed. Si K no es cero, se quitan todos los miembros con un número diferente de parámetros de tipo.If K is not zero, all members with a different number of type parameters are removed. Tenga en cuenta que cuando K es cero, no se quitan los métodos que tienen parámetros de tipo, ya que el proceso de inferencia de tipos (inferencia de tipos) podría inferir los argumentos de tipo.Note that when K is zero, methods having type parameters are not removed, since the type inference process (Type inference) might be able to infer the type arguments.
• Después, si se invoca el miembro, todos los miembros que no sean de invocable se quitarán del conjunto.Next, if the member is invoked, all non-invocable members are removed from the set.
• Después, los miembros que están ocultos por otros miembros se quitan del conjunto.Next, members that are hidden by other members are removed from the set. Para cada miembro del S.M conjunto, donde S es el tipo en el que  M se declara el miembro, se aplican las siguientes reglas: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:
  • Si M es una constante, un campo, una propiedad, un evento o un miembro de enumeración, todos los miembros declarados en un tipo base de S se quitan del conjunto.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.
  • Si M es una declaración de tipos, todos los tipos que no sean declarados en un tipo base de S se quitan del conjunto y todas las declaraciones de tipos con el mismo número de parámetros de tipo M declarados en un tipo base de S se quitan del conjunto.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.
  • Si M es un método, todos los miembros que no sean de método declarados en un tipo base de S se quitan del conjunto.If M is a method, then all non-method members declared in a base type of S are removed from the set.
• Después, los miembros de interfaz que están ocultos por miembros de clase se quitan del conjunto.Next, interface members that are hidden by class members are removed from the set. Este paso solo tiene efecto si T es un parámetro de tipo y T tiene una clase base efectiva distinta de object y un conjunto de interfaces efectivo que no está vacío (restricciones de parámetro de tipo).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 (Type parameter constraints). Para cada miembro del S.M conjunto, donde S es el tipo en el que se declara el miembro M , se aplican las reglas siguientes si S es una declaración de clase distinta de object :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:
  • Si M es una constante, un campo, una propiedad, un evento, un miembro de enumeración o una declaración de tipos, todos los miembros declarados en una declaración de interfaz se quitan del conjunto.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.
  • Si M es un método, se quitan del conjunto todos los miembros que no son de método declarados en una declaración de interfaz y todos los métodos con la misma firma que M se declaran en una declaración de interfaz se quitan del conjunto.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.
• Por último, si se han quitado los miembros ocultos, se determina el resultado de la búsqueda:Finally, having removed hidden members, the result of the lookup is determined:
  • Si el conjunto está formado por un único miembro que no es un método, este miembro es el resultado de la búsqueda.If the set consists of a single member that is not a method, then this member is the result of the lookup.
  • De lo contrario, si el conjunto solo contiene métodos, este grupo de métodos es el resultado de la búsqueda.Otherwise, if the set contains only methods, then this group of methods is the result of the lookup.
  • De lo contrario, la búsqueda es ambigua y se produce un error en tiempo de enlace.Otherwise, the lookup is ambiguous, and a binding-time error occurs.

Para búsquedas de miembros en tipos que no sean de tipo e interfaces, y búsquedas de miembros en interfaces que son estrictamente de herencia única (cada interfaz de la cadena de herencia tiene exactamente cero o una interfaz base directa), el efecto de las reglas de búsqueda es simplemente que los miembros derivados ocultan los miembros base con el mismo nombre o signatura.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. Dichas búsquedas de herencia única nunca son ambiguas.Such single-inheritance lookups are never ambiguous. Las ambigüedades que pueden surgir en las búsquedas de miembros en interfaces de herencia múltiple se describen en acceso a miembros de interfaz.The ambiguities that can possibly arise from member lookups in multiple-inheritance interfaces are described in Interface member access.

Tipos baseBase types

En lo que respecta a la búsqueda de miembros, T se considera que un tipo tiene los siguientes tipos base:For purposes of member lookup, a type T is considered to have the following base types:

• Si T es object , T no tiene ningún tipo base.If T is object, then T has no base type.
• Si T es un enum_type, los tipos base de T son los tipos de clase System.Enum , System.ValueType y object .If T is an enum_type, the base types of T are the class types System.Enum, System.ValueType, and object.
• Si T es un struct_type, los tipos base de T son los tipos de clase System.ValueType y object .If T is a struct_type, the base types of T are the class types System.ValueType and object.
• Si T es un class_type, los tipos base de T son las clases base de T , incluido el tipo de clase object .If T is a class_type, the base types of T are the base classes of T, including the class type object.
• Si T es un interface_type, los tipos base de T son las interfaces base de T y el tipo de clase object .If T is an interface_type, the base types of T are the base interfaces of T and the class type object.
• Si T es un array_type, los tipos base de T son los tipos de clase System.Array y object .If T is an array_type, the base types of T are the class types System.Array and object.
• Si T es un delegate_type, los tipos base de T son los tipos de clase System.Delegate y object .If T is a delegate_type, the base types of T are the class types System.Delegate and object.

Miembros de funciónFunction members

Los miembros de función son miembros que contienen instrucciones ejecutables.Function members are members that contain executable statements. Los miembros de función siempre son miembros de tipos y no pueden ser miembros de espacios de nombres.Function members are always members of types and cannot be members of namespaces. C# define las siguientes categorías de miembros de función:C# defines the following categories of function members:

• MétodosMethods
• PropiedadesProperties
• EventsEvents
• IndizadoresIndexers
• Operadores definidos por el usuarioUser-defined operators
• Constructores de instanciasInstance constructors
• Constructores estáticosStatic constructors
• DestructoresDestructors

A excepción de los destructores y los constructores estáticos (que no se pueden invocar explícitamente), las instrucciones contenidas en miembros de función se ejecutan a través de las invocaciones de miembros de función.Except for destructors and static constructors (which cannot be invoked explicitly), the statements contained in function members are executed through function member invocations. La sintaxis real para escribir una invocación de miembros de función depende de la categoría de miembro de función determinada.The actual syntax for writing a function member invocation depends on the particular function member category.

La lista de argumentos (listas de argumentos) de una invocación de miembros de función proporciona valores reales o referencias de variable para los parámetros del miembro de función.The argument list (Argument lists) of a function member invocation provides actual values or variable references for the parameters of the function member.

Las invocaciones de métodos genéricos pueden emplear la inferencia de tipos para determinar el conjunto de argumentos de tipo que se van a pasar al método.Invocations of generic methods may employ type inference to determine the set of type arguments to pass to the method. Este proceso se describe en inferencia de tipos.This process is described in Type inference.

Las invocaciones de métodos, indizadores, operadores y constructores de instancia emplean la resolución de sobrecarga para determinar cuál de un conjunto candidato de miembros de función se va a invocar.Invocations of methods, indexers, operators and instance constructors employ overload resolution to determine which of a candidate set of function members to invoke. Este proceso se describe en resolución de sobrecarga.This process is described in Overload resolution.

Una vez que se ha identificado un miembro de función determinado en tiempo de enlace, posiblemente a través de la resolución de sobrecarga, el proceso real en tiempo de ejecución de la invocación del miembro de función se describe en la comprobación en tiempo de compilación de la resolución de sobrecarga dinámica.Once a particular function member has been identified at binding-time, possibly through overload resolution, the actual run-time process of invoking the function member is described in Compile-time checking of dynamic overload resolution.

En la tabla siguiente se resume el procesamiento que tiene lugar en construcciones que implican las seis categorías de miembros de función que se pueden invocar explícitamente.The following table summarizes the processing that takes place in constructs involving the six categories of function members that can be explicitly invoked. En la tabla,,, e x y y value indican expresiones clasificadas como variables o valores, T indica una expresión clasificada como un tipo, F es el nombre simple de un método y P es el nombre simple de una propiedad.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.

Listas de argumentosArgument lists

Cada invocación de miembro de función y delegado incluye una lista de argumentos que proporciona valores reales o referencias de variable para los parámetros del miembro de función.Every function member and delegate invocation includes an argument list which provides actual values or variable references for the parameters of the function member. La sintaxis para especificar la lista de argumentos de una invocación de miembros de función depende de la categoría de miembros de función:The syntax for specifying the argument list of a function member invocation depends on the function member category:

• En el caso de los constructores de instancias, los métodos, los indizadores y los delegados, los argumentos se especifican como un argument_list, como se describe a continuación.For instance constructors, methods, indexers and delegates, the arguments are specified as an argument_list, as described below. En el caso de los indizadores, al invocar el set descriptor de acceso, la lista de argumentos incluye también la expresión especificada como operando derecho del operador de asignación.For indexers, when invoking the set accessor, the argument list additionally includes the expression specified as the right operand of the assignment operator.
• En el caso de las propiedades, la lista de argumentos está vacía al invocar el get descriptor de acceso y se compone de la expresión especificada como operando derecho del operador de asignación al invocar el set descriptor de acceso.For properties, the argument list is empty when invoking the get accessor, and consists of the expression specified as the right operand of the assignment operator when invoking the set accessor.
• En el caso de los eventos, la lista de argumentos se compone de la expresión especificada como operando derecho del += -= operador o.For events, the argument list consists of the expression specified as the right operand of the += or -= operator.
• En el caso de los operadores definidos por el usuario, la lista de argumentos se compone del operando único del operador unario o de los dos operandos del operador binario.For user-defined operators, the argument list consists of the single operand of the unary operator or the two operands of the binary operator.

Los argumentos de las propiedades (propiedades), los eventos (eventos) y los operadores definidos por el usuario (operadores) siempre se pasan como parámetros de valor (parámetros de valor).The arguments of properties (Properties), events (Events), and user-defined operators (Operators) are always passed as value parameters (Value parameters). Los argumentos de los indizadores (indizadores) siempre se pasan como parámetros de valor (parámetros de valor) o como matrices de parámetros (matrices deparámetros).The arguments of indexers (Indexers) are always passed as value parameters (Value parameters) or parameter arrays (Parameter arrays). Los parámetros de referencia y de salida no se admiten para estas categorías de miembros de función.Reference and output parameters are not supported for these categories of function members.

Los argumentos de una invocación de constructor de instancia, método, indexador o delegado se especifican como un argument_list:The arguments of an instance constructor, method, indexer or delegate invocation are specified as an argument_list:

argument_list
    : argument (',' argument)*
    ;

argument
    : argument_name? argument_value
    ;

argument_name
    : identifier ':'
    ;

argument_value
    : expression
    | 'ref' variable_reference
    | 'out' variable_reference
    ;

Una argument_list está formada por uno o más argumentos, separados por comas.An argument_list consists of one or more argument s, separated by commas. Cada argumento consta de un argument_name opcional seguido de un argument_value.Each argument consists of an optional argument_name followed by an argument_value. Un argumento con un argument_name se conoce como un argumento *con nombre, mientras que un argumento * sin un argument_name es un argumento posicional*.An argument with an argument_name is referred to as a named argument _, whereas an _argument without an argument_name is a *positional argument_. Es un error que un argumento posicional aparezca después de un argumento con nombre en un _argument_list *.It is an error for a positional argument to appear after a named argument in an _argument_list*.

El argument_value puede adoptar uno de los siguientes formatos:The argument_value can take one of the following forms:

• Una expresión, que indica que el argumento se pasa como parámetro de valor (parámetros de valor).An expression, indicating that the argument is passed as a value parameter (Value parameters).
• Palabra clave ref seguida de un variable_reference (referencias de variable), que indica que el argumento se pasa como parámetro de referencia (parámetros de referencia).The keyword ref followed by a variable_reference (Variable references), indicating that the argument is passed as a reference parameter (Reference parameters). Una variable debe estar asignada definitivamente (asignación definitiva) antes de que se pueda pasar como un parámetro de referencia.A variable must be definitely assigned (Definite assignment) before it can be passed as a reference parameter. Palabra clave out seguida de un variable_reference (referencias de variable), que indica que el argumento se pasa como parámetro de salida (parámetros de salida).The keyword out followed by a variable_reference (Variable references), indicating that the argument is passed as an output parameter (Output parameters). Una variable se considera asignada definitivamente (asignación definitiva) después de una invocación de miembro de función en la que se pasa la variable como parámetro de salida.A variable is considered definitely assigned (Definite assignment) following a function member invocation in which the variable is passed as an output parameter.

Parámetros correspondientesCorresponding parameters

Para cada argumento de una lista de argumentos debe haber un parámetro correspondiente en el miembro de función o el delegado que se va a invocar.For each argument in an argument list there has to be a corresponding parameter in the function member or delegate being invoked.

La lista de parámetros que se utiliza en lo siguiente se determina de la siguiente manera:The parameter list used in the following is determined as follows:

• En el caso de los métodos virtuales y los indizadores definidos en las clases, la lista de parámetros se elige de la declaración o invalidación más específica del miembro de función, empezando por el tipo estático del receptor y buscando en sus clases base.For virtual methods and indexers defined in classes, the parameter list is picked from the most specific declaration or override of the function member, starting with the static type of the receiver, and searching through its base classes.
• En el caso de los métodos e indexadores de la interfaz, la lista de parámetros se selecciona como la definición más específica del miembro, empezando por el tipo de interfaz y buscando en las interfaces base.For interface methods and indexers, the parameter list is picked form the most specific definition of the member, starting with the interface type and searching through the base interfaces. Si no se encuentra ninguna lista de parámetros única, se construye una lista de parámetros con nombres inaccesibles y ningún parámetro opcional, de modo que las invocaciones no pueden usar parámetros con nombre u omitir argumentos opcionales.If no unique parameter list is found, a parameter list with inaccessible names and no optional parameters is constructed, so that invocations cannot use named parameters or omit optional arguments.
• Para los métodos parciales, se usa la lista de parámetros de la declaración de método parcial de definición.For partial methods, the parameter list of the defining partial method declaration is used.
• En el caso de todos los demás miembros de función y delegados, solo hay una lista de parámetros única, que es la que se usa.For all other function members and delegates there is only a single parameter list, which is the one used.

La posición de un argumento o parámetro se define como el número de argumentos o parámetros que lo preceden en la lista de argumentos o en la lista de parámetros.The position of an argument or parameter is defined as the number of arguments or parameters preceding it in the argument list or parameter list.

Los parámetros correspondientes para los argumentos de miembro de función se establecen de la siguiente manera:The corresponding parameters for function member arguments are established as follows:

• Argumentos en el argument_list de constructores de instancia, métodos, indizadores y delegados:Arguments in the argument_list of instance constructors, methods, indexers and delegates:
  • Un argumento posicional en el que se produce un parámetro fijo en la misma posición en la lista de parámetros corresponde a ese parámetro.A positional argument where a fixed parameter occurs at the same position in the parameter list corresponds to that parameter.
  • Un argumento posicional de un miembro de función con una matriz de parámetros invocada en su forma normal corresponde a la matriz de parámetros, que debe aparecer en la misma posición en la lista de parámetros.A positional argument of a function member with a parameter array invoked in its normal form corresponds to the parameter array, which must occur at the same position in the parameter list.
  • Argumento posicional de un miembro de función con una matriz de parámetros invocada en su forma expandida, donde no se produce ningún parámetro fijo en la misma posición en la lista de parámetros, corresponde a un elemento de la matriz de parámetros.A positional argument of a function member with a parameter array invoked in its expanded form, where no fixed parameter occurs at the same position in the parameter list, corresponds to an element in the parameter array.
  • Un argumento con nombre corresponde al parámetro con el mismo nombre en la lista de parámetros.A named argument corresponds to the parameter of the same name in the parameter list.
  • En el caso de los indizadores, al invocar el set descriptor de acceso, la expresión especificada como operando derecho del operador de asignación corresponde al value parámetro implícito de la set declaración del descriptor de acceso.For indexers, when invoking the set accessor, the expression specified as the right operand of the assignment operator corresponds to the implicit value parameter of the set accessor declaration.
• En el caso de las propiedades, al invocar el get descriptor de acceso no hay ningún argumento.For properties, when invoking the get accessor there are no arguments. Al invocar el set descriptor de acceso, la expresión especificada como operando derecho del operador de asignación corresponde al value parámetro implícito de la set declaración del descriptor de acceso.When invoking the set accessor, the expression specified as the right operand of the assignment operator corresponds to the implicit value parameter of the set accessor declaration.
• En el caso de los operadores unarios definidos por el usuario (incluidas las conversiones), el único operando corresponde al parámetro único de la declaración del operador.For user-defined unary operators (including conversions), the single operand corresponds to the single parameter of the operator declaration.
• En el caso de los operadores binarios definidos por el usuario, el operando izquierdo corresponde al primer parámetro y el operando derecho se corresponde con el segundo parámetro de la declaración del operador.For user-defined binary operators, the left operand corresponds to the first parameter, and the right operand corresponds to the second parameter of the operator declaration.

Evaluación en tiempo de ejecución de listas de argumentosRun-time evaluation of argument lists

Durante el procesamiento en tiempo de ejecución de una invocación de miembro de función (comprobación en tiempo de compilación de la resolución dinámica de sobrecarga), las expresiones o referencias de variables de una lista de argumentos se evalúan en orden, de izquierda a derecha, de la manera siguiente:During the run-time processing of a function member invocation (Compile-time checking of dynamic overload resolution), the expressions or variable references of an argument list are evaluated in order, from left to right, as follows:

• Para un parámetro de valor, se evalúa la expresión de argumento y se realiza una conversión implícita (conversiones implícitas) en el tipo de parámetro correspondiente.For a value parameter, the argument expression is evaluated and an implicit conversion (Implicit conversions) to the corresponding parameter type is performed. El valor resultante se convierte en el valor inicial del parámetro de valor en la invocación del miembro de función.The resulting value becomes the initial value of the value parameter in the function member invocation.
• Para un parámetro de referencia o de salida, se evalúa la referencia de la variable y la ubicación de almacenamiento resultante se convierte en la ubicación de almacenamiento representada por el parámetro en la invocación del miembro de función.For a reference or output parameter, the variable reference is evaluated and the resulting storage location becomes the storage location represented by the parameter in the function member invocation. Si la referencia de variable dada como parámetro de referencia o de salida es un elemento de matriz de un reference_type, se realiza una comprobación en tiempo de ejecución para asegurarse de que el tipo de elemento de la matriz es idéntico al tipo del parámetro.If the variable reference given as a reference or output parameter is an array element of a reference_type, a run-time check is performed to ensure that the element type of the array is identical to the type of the parameter. Si se produce un error en esta comprobación, System.ArrayTypeMismatchException se produce una excepción.If this check fails, a System.ArrayTypeMismatchException is thrown.

Los métodos, indizadores y constructores de instancias pueden declarar su parámetro situado más a la derecha para que sea una matriz de parámetros (matrices de parámetros).Methods, indexers, and instance constructors may declare their right-most parameter to be a parameter array (Parameter arrays). Estos miembros de función se invocan en su forma normal o en su forma expandida, en función de cuál sea aplicable (miembro de función aplicable):Such function members are invoked either in their normal form or in their expanded form depending on which is applicable (Applicable function member):

• Cuando se invoca un miembro de función con una matriz de parámetros en su forma normal, el argumento dado para la matriz de parámetros debe ser una expresión única que se pueda convertir implícitamente (conversiones implícitas) al tipo de matriz de parámetros.When a function member with a parameter array is invoked in its normal form, the argument given for the parameter array must be a single expression that is implicitly convertible (Implicit conversions) to the parameter array type. En este caso, la matriz de parámetros actúa exactamente como un parámetro de valor.In this case, the parameter array acts precisely like a value parameter.
• Cuando se invoca un miembro de función con una matriz de parámetros en su forma expandida, la invocación debe especificar cero o más argumentos posicionales para la matriz de parámetros, donde cada argumento es una expresión que es convertible implícitamente (conversiones implícitas) al tipo de elemento de la matriz de parámetros.When a function member with a parameter array is invoked in its expanded form, the invocation must specify zero or more positional arguments for the parameter array, where each argument is an expression that is implicitly convertible (Implicit conversions) to the element type of the parameter array. En este caso, la invocación crea una instancia del tipo de matriz de parámetros con una longitud correspondiente al número de argumentos, inicializa los elementos de la instancia de la matriz con los valores de argumento especificados y utiliza la instancia de matriz recién creada como argumento real.In this case, the invocation creates an instance of the parameter array type with a length corresponding to the number of arguments, initializes the elements of the array instance with the given argument values, and uses the newly created array instance as the actual argument.

Las expresiones de una lista de argumentos siempre se evalúan en el orden en que se escriben.The expressions of an argument list are always evaluated in the order they are written. Por lo tanto, el ejemploThus, the example

class Test
{
    static void F(int x, int y = -1, int z = -2) {
        System.Console.WriteLine("x = {0}, y = {1}, z = {2}", x, y, z);
    }

    static void Main() {
        int i = 0;
        F(i++, i++, i++);
        F(z: i++, x: i++);
    }
}

genera el resultadoproduces the output

x = 0, y = 1, z = 2
x = 4, y = -1, z = 3

Las reglas de covarianza de matriz (covarianza de matriz) permiten que un valor de un tipo de matriz A[] sea una referencia a una instancia de un tipo de matriz B[] , siempre que exista una conversión de referencia implícita de B a A .The array co-variance rules (Array covariance) permit a value of an array type A[] to be a reference to an instance of an array type B[], provided an implicit reference conversion exists from B to A. Debido a estas reglas, cuando un elemento de matriz de un reference_type se pasa como parámetro de referencia o de salida, se requiere una comprobación en tiempo de ejecución para asegurarse de que el tipo de elemento real de la matriz es idéntico al del parámetro.Because of these rules, when an array element of a reference_type is passed as a reference or output parameter, a run-time check is required to ensure that the actual element type of the array is identical to that of the parameter. En el ejemploIn the example

class Test
{
    static void F(ref object x) {...}

    static void Main() {
        object[] a = new object[10];
        object[] b = new string[10];
        F(ref a[0]);        // Ok
        F(ref b[1]);        // ArrayTypeMismatchException
    }
}

la segunda invocación de F hace que System.ArrayTypeMismatchException se produzca una excepción porque el tipo de elemento real de b es string y no object .the second invocation of F causes a System.ArrayTypeMismatchException to be thrown because the actual element type of b is string and not object.

Cuando se invoca un miembro de función con una matriz de parámetros en su forma expandida, la invocación se procesa exactamente como si se hubiera insertado una expresión de creación de matriz con un inicializador de matriz (expresiones de creación de matriz) alrededor de los parámetros expandidos.When a function member with a parameter array is invoked in its expanded form, the invocation is processed exactly as if an array creation expression with an array initializer (Array creation expressions) was inserted around the expanded parameters. Por ejemplo, dada la declaraciónFor example, given the declaration

void F(int x, int y, params object[] args);

las siguientes invocaciones de la forma expandida del métodothe following invocations of the expanded form of the method

F(10, 20);
F(10, 20, 30, 40);
F(10, 20, 1, "hello", 3.0);

se corresponde exactamente concorrespond exactly to

F(10, 20, new object[] {});
F(10, 20, new object[] {30, 40});
F(10, 20, new object[] {1, "hello", 3.0});

En concreto, tenga en cuenta que se crea una matriz vacía cuando no hay ningún argumento dado para la matriz de parámetros.In particular, note that an empty array is created when there are zero arguments given for the parameter array.

Cuando se omiten los argumentos de un miembro de función con los parámetros opcionales correspondientes, se pasan implícitamente los argumentos predeterminados de la declaración de miembro de función.When arguments are omitted from a function member with corresponding optional parameters, the default arguments of the function member declaration are implicitly passed. Dado que siempre son constantes, su evaluación no afectará al orden de evaluación de los argumentos restantes.Because these are always constant, their evaluation will not impact the evaluation order of the remaining arguments.

Inferencia de tiposType inference

Cuando se llama a un método genérico sin especificar argumentos de tipo, un proceso de inferencia de tipos intenta deducir los argumentos de tipo de la llamada.When a generic method is called without specifying type arguments, a type inference process attempts to infer type arguments for the call. La presencia de la inferencia de tipos permite usar una sintaxis más cómoda para llamar a un método genérico y permite al programador evitar especificar información de tipos redundantes.The presence of type inference allows a more convenient syntax to be used for calling a generic method, and allows the programmer to avoid specifying redundant type information. Por ejemplo, dada la declaración del método:For example, given the method declaration:

class Chooser
{
    static Random rand = new Random();

    public static T Choose<T>(T first, T second) {
        return (rand.Next(2) == 0)? first: second;
    }
}

es posible invocar el Choose método sin especificar explícitamente un argumento de tipo:it is possible to invoke the Choose method without explicitly specifying a type argument:

int i = Chooser.Choose(5, 213);                 // Calls Choose<int>

string s = Chooser.Choose("foo", "bar");        // Calls Choose<string>

A través de la inferencia de tipos, los argumentos de tipo int y string se determinan a partir de los argumentos del método.Through type inference, the type arguments int and string are determined from the arguments to the method.

La inferencia de tipos se produce como parte del procesamiento en tiempo de enlace de una invocación de método (invocaciones de método) y tiene lugar antes del paso de resolución de sobrecarga de la invocación.Type inference occurs as part of the binding-time processing of a method invocation (Method invocations) and takes place before the overload resolution step of the invocation. Cuando se especifica un grupo de métodos determinado en una invocación de método y no se especifica ningún argumento de tipo como parte de la invocación del método, se aplica la inferencia de tipos a cada método genérico del grupo de métodos.When a particular method group is specified in a method invocation, and no type arguments are specified as part of the method invocation, type inference is applied to each generic method in the method group. Si la inferencia de tipos se realiza correctamente, los argumentos de tipo deducido se usan para determinar los tipos de argumentos para la resolución de sobrecarga subsiguiente.If type inference succeeds, then the inferred type arguments are used to determine the types of arguments for subsequent overload resolution. Si la resolución de sobrecarga elige un método genérico como el que se va a invocar, los argumentos de tipo deducido se usan como argumentos de tipo reales para la invocación.If overload resolution chooses a generic method as the one to invoke, then the inferred type arguments are used as the actual type arguments for the invocation. Si se produce un error en la inferencia de tipos para un método determinado, ese método no participa en la resolución de sobrecarga.If type inference for a particular method fails, that method does not participate in overload resolution. El error de inferencia de tipos, en y de sí mismo, no produce un error en tiempo de enlace.The failure of type inference, in and of itself, does not cause a binding-time error. Sin embargo, a menudo se produce un error en tiempo de enlace cuando la resolución de sobrecarga no encuentra ningún método aplicable.However, it often leads to a binding-time error when overload resolution then fails to find any applicable methods.

Si el número de argumentos proporcionado es diferente del número de parámetros del método, se producirá un error inmediatamente en la inferencia.If the supplied number of arguments is different than the number of parameters in the method, then inference immediately fails. En caso contrario, supongamos que el método genérico tiene la siguiente firma:Otherwise, assume that the generic method has the following signature:

Tr M<X1,...,Xn>(T1 x1, ..., Tm xm)

Con una llamada al método de la forma M(E1...Em) , la tarea de inferencia de tipo es buscar argumentos S1...Sn de tipo únicos para cada uno de los parámetros de tipo X1...Xn , de modo que la llamada M<S1...Sn>(E1...Em) sea válida.With a method call of the form M(E1...Em) the task of type inference is to find unique type arguments S1...Sn for each of the type parameters X1...Xn so that the call M<S1...Sn>(E1...Em) becomes valid.

Durante el proceso de inferencia, cada parámetro de tipo Xi se fija en un tipo determinado Si o se desfija con un conjunto de límites asociado.During the process of inference each type parameter Xi is either fixed to a particular type Si or unfixed with an associated set of bounds. Cada uno de los límites es algún tipo T .Each of the bounds is some type T. Inicialmente, cada variable Xi de tipo se desfija con un conjunto vacío de límites.Initially each type variable Xi is unfixed with an empty set of bounds.

La inferencia de tipos tiene lugar en fases.Type inference takes place in phases. Cada fase intentará deducir los argumentos de tipo para obtener más variables de tipo basadas en los resultados de la fase anterior.Each phase will try to infer type arguments for more type variables based on the findings of the previous phase. La primera fase realiza algunas inferencias iniciales de límites, mientras que en la segunda fase se corrigen las variables de tipo a tipos específicos y se deducen más límites.The first phase makes some initial inferences of bounds, whereas the second phase fixes type variables to specific types and infers further bounds. Es posible que la segunda fase se repita varias veces.The second phase may have to be repeated a number of times.

Nota: La inferencia de tipos no solo tiene lugar cuando se llama a un método genérico.Note: Type inference takes place not only when a generic method is called. La inferencia de tipos para la conversión de grupos de métodos se describe en inferencia de tipos para la conversión de grupos de métodos y encontrar el mejor tipo común de un conjunto de expresiones se describe en Buscar el mejor tipo común de un conjunto de expresiones.Type inference for conversion of method groups is described in Type inference for conversion of method groups and finding the best common type of a set of expressions is described in Finding the best common type of a set of expressions.

La primera faseThe first phase

Para cada uno de los argumentos del método Ei :For each of the method arguments Ei:

• Si Ei es una función anónima, se realiza una inferencia de tipo de parámetro explícita (inferencias de tipos de parámetros explícitos) de Ei a TiIf Ei is an anonymous function, an explicit parameter type inference (Explicit parameter type inferences) is made from Ei to Ti
• De lo contrario, si Ei tiene un tipo U y xi es un parámetro de valor, se realiza una inferencia de enlace inferior desde U a Ti .Otherwise, if Ei has a type U and xi is a value parameter then a lower-bound inference is made from U to Ti.
• De lo contrario, si Ei tiene un tipo U y xi es un ref out parámetro o, se realiza una inferencia exacta desde U a Ti .Otherwise, if Ei has a type U and xi is a ref or out parameter then an exact inference is made from U to Ti.
• De lo contrario, no se realiza ninguna inferencia para este argumento.Otherwise, no inference is made for this argument.

La segunda faseThe second phase

La segunda fase continúa como sigue:The second phase proceeds as follows:

• Todas las variables de tipo Xi sin corregir que no dependen de (dependencia) Xj se corrigen (corrigiendo).All unfixed type variables Xi which do not depend on (Dependence) any Xj are fixed (Fixing).
• Si no existe ninguna variable de tipo, se fijan todas las variables de tipo no fijas Xi para las que se retrasen:If no such type variables exist, all unfixed type variables Xi are fixed for which all of the following hold:
  • Hay al menos una variable de tipo Xj que depende de XiThere is at least one type variable Xj that depends on Xi
  • Xi tiene un conjunto de límites no vacíoXi has a non-empty set of bounds
• Si no existe ninguna variable de tipo y hay variables de tipo sin corregir , se produce un error en la inferencia de tipos.If no such type variables exist and there are still unfixed type variables, type inference fails.
• De lo contrario, si no existen más variables de tipo sin corregir , la inferencia de tipos se realiza correctamente.Otherwise, if no further unfixed type variables exist, type inference succeeds.
• De lo contrario, para todos los argumentos Ei con el tipo de parámetro correspondiente Ti en el que los tipos de salida (tipos de salida) contienen variables de tipo sin corregir Xj pero los tipos de entrada (tipos de entrada) no, una inferencia de tipo de salida (inferencias de tipo de salida) se realiza desde Ei a Ti .Otherwise, for all arguments Ei with corresponding parameter type Ti where the output types (Output types) contain unfixed type variables Xj but the input types (Input types) do not, an output type inference (Output type inferences) is made from Ei to Ti. A continuación, se repite la segunda fase.Then the second phase is repeated.

Tipos de entradaInput types

Si E es un grupo de métodos o una función anónima con tipos implícitos y T es un tipo de delegado o un tipo de árbol de expresión, todos los tipos de parámetro de T son tipos de entrada de tipo E T .If E is a method group or implicitly typed anonymous function and T is a delegate type or expression tree type then all the parameter types of T are input types of E with type T.

Tipos de salidaOutput types

Si E es un grupo de métodos o una función anónima y T es un tipo de delegado o un tipo de árbol de expresión, el tipo de valor devuelto de T es un tipo de salida de E con el tipo T .If E is a method group or an anonymous function and T is a delegate type or expression tree type then the return type of T is an output type of E with type T.

DependenciaDependence

Una variable de tipo sin fijo Xi depende directamente de una variable de tipo sin corregir Xj si para algún argumento Ek con tipo Tk Xj se produce en un tipo de entrada de Ek con el tipo Tk y Xi se produce en un tipo de salida de Ek con el tipo Tk .An unfixed type variable Xi depends directly on an unfixed type variable Xj if for some argument Ek with type Tk Xj occurs in an input type of Ek with type Tk and Xi occurs in an output type of Ek with type Tk.

Xjdepende de Xi Si Xj depende directamente de Xi o si Xi depende directamente de Xk y Xk depende de Xj .Xj depends on Xi if Xj depends directly on Xi or if Xi depends directly on Xk and Xk depends on Xj. Por lo tanto, "depende de" es el cierre transitivo pero no reflexivo de "depende directamente de".Thus "depends on" is the transitive but not reflexive closure of "depends directly on".

Inferencias de tipos de salidaOutput type inferences

Una inferencia de tipo de salida se realiza desde una expresión E a un tipo T de la siguiente manera:An output type inference is made from an expression E to a type T in the following way:

• Si E es una función anónima con el tipo de valor devuelto inferido U (tipo de valordevuelto deducido) y es un tipo de T delegado o un tipo de árbol de expresión con el tipo de valor devuelto Tb , una inferencia de límite inferior (inferencias de límite inferior) se realiza desde U a Tb .If E is an anonymous function with inferred return type U (Inferred return type) and T is a delegate type or expression tree type with return type Tb, then a lower-bound inference (Lower-bound inferences) is made from U to Tb.
• De lo contrario, si E es un grupo de métodos y T es un tipo de delegado o de árbol de expresión con tipos de parámetro T1...Tk y tipo de valor devuelto Tb , y la resolución de sobrecarga de E con los tipos T1...Tk produce un único método con el tipo de valor devuelto U , se realiza una inferencia de enlace inferior desde U a Tb .Otherwise, if E is a method group and T is a delegate type or expression tree type with parameter types T1...Tk and return type Tb, and overload resolution of E with the types T1...Tk yields a single method with return type U, then a lower-bound inference is made from U to Tb.
• De lo contrario, si E es una expresión de tipo U , se realiza una inferencia de enlace inferior desde U a T .Otherwise, if E is an expression with type U, then a lower-bound inference is made from U to T.
• De lo contrario, no se realiza ninguna inferencia.Otherwise, no inferences are made.

Inferencias explícitas de tipos de parámetrosExplicit parameter type inferences

Una inferencia de tipo de parámetro explícita se realiza desde una expresión E a un tipo T de la siguiente manera:An explicit parameter type inference is made from an expression E to a type T in the following way:

• Si E es una función anónima con tipo explícito con tipos de parámetro U1...Uk y T es un tipo de delegado o un tipo de árbol de expresión con tipos de parámetro V1...Vk, para cada Ui se realiza una inferencia exacta (inferencias exactas) desde Ui hasta el Vi correspondienteIf E is an explicitly typed anonymous function with parameter types U1...Uk and T is a delegate type or expression tree type with parameter types V1...Vk then for each Ui an exact inference (Exact inferences) is made from Ui to the corresponding Vi.

Inferencias exactasExact inferences

Una inferencia exacta de un tipo U a un tipo V se realiza de la siguiente manera:An exact inference from a type U to a type V is made as follows:

• Si V es uno de los fijos Xi , U se agrega al conjunto de límites exactos para Xi .If V is one of the unfixed Xi then U is added to the set of exact bounds for Xi.

• De lo contrario V1...Vk , U1...Uk los conjuntos y se determinan comprobando si se aplica cualquiera de los casos siguientes:Otherwise, sets V1...Vk and U1...Uk are determined by checking if any of the following cases apply:

  • V es un tipo V1[...] de matriz y U es un tipo U1[...] de matriz del mismo rangoV is an array type V1[...] and U is an array type U1[...] of the same rank
  • V es el tipo V1? y U es el tipo. U1?V is the type V1? and U is the type U1?
  • V es un tipo construido C<V1...Vk> y U es un tipo construido. C<U1...Uk>V is a constructed type C<V1...Vk>and U is a constructed type C<U1...Uk>

  Si se aplica cualquiera de estos casos, se realiza una inferencia exacta desde cada Ui hasta el correspondiente Vi .If any of these cases apply then an exact inference is made from each Ui to the corresponding Vi.

• En caso contrario, no se realiza ninguna inferencia.Otherwise no inferences are made.

Inferencias con límite inferiorLower-bound inferences

Una inferencia de límite inferior desde un tipo U a un tipo V se realiza de la siguiente manera:A lower-bound inference from a type U to a type V is made as follows:

• Si V es uno de los desfijos Xi , U se agrega al conjunto de límites inferiores para Xi .If V is one of the unfixed Xi then U is added to the set of lower bounds for Xi.

• De lo contrario, si V es el tipo V1? y U es el tipo U1? , se realiza una inferencia de límite inferior desde U1 a V1 .Otherwise, if V is the type V1?and U is the type U1? then a lower bound inference is made from U1 to V1.

• De lo contrario U1...Uk , V1...Vk los conjuntos y se determinan comprobando si se aplica cualquiera de los casos siguientes:Otherwise, sets U1...Uk and V1...Vk are determined by checking if any of the following cases apply:

  • V es un tipo V1[...] de matriz y U es un tipo U1[...] de matriz (o un parámetro de tipo cuyo tipo base efectivo es U1[...] ) del mismo rangoV is an array type V1[...] and U is an array type U1[...] (or a type parameter whose effective base type is U1[...]) of the same rank

  • V es uno de IEnumerable<V1> , ICollection<V1> o IList<V1> y U es un tipo de matriz unidimensional U1[] (o un parámetro de tipo cuyo tipo base efectivo es U1[] )V is one of IEnumerable<V1>, ICollection<V1> or IList<V1> and U is a one-dimensional array type U1[](or a type parameter whose effective base type is U1[])

  • V es una clase, un struct, una interfaz o un tipo de delegado construidos C<V1...Vk> y hay un tipo único C<U1...Uk> , de modo que U (o, si U es un parámetro de tipo, su clase base efectiva o cualquier miembro de su conjunto de interfaz efectivo) es idéntico a, hereda de (directa o indirectamente) o implementa (directa o indirectamente) C<U1...Uk> .V is a constructed class, struct, interface or delegate type C<V1...Vk> and there is a unique type C<U1...Uk> such that U (or, if U is a type parameter, its effective base class or any member of its effective interface set) is identical to, inherits from (directly or indirectly), or implements (directly or indirectly) C<U1...Uk>.

    (La restricción de unicidad significa que, en la interfaz Case C<T> {} class U: C<X>, C<Y> {} , no se realiza ninguna inferencia al deducir de U a C<T> porque U1 puede ser X o Y ).(The "uniqueness" restriction means that in the case interface C<T> {} class U: C<X>, C<Y> {}, then no inference is made when inferring from U to C<T> because U1 could be X or Y.)

  Si se aplica cualquiera de estos casos, se realiza una inferencia desde cada Ui hasta el correspondiente, como se indica a continuación Vi :If any of these cases apply then an inference is made from each Ui to the corresponding Vi as follows:

  • Si Ui no se sabe que es un tipo de referencia, se realiza una inferencia exacta .If Ui is not known to be a reference type then an exact inference is made
  • De lo contrario, si U es un tipo de matriz, se realiza una inferencia de límite inferior .Otherwise, if U is an array type then a lower-bound inference is made
  • De lo contrario, si V es C<V1...Vk> , la inferencia depende del parámetro de tipo i-ésima de C :Otherwise, if V is C<V1...Vk> then inference depends on the i-th type parameter of C:
    • Si es covariante, se realiza una inferencia de límite inferior .If it is covariant then a lower-bound inference is made.
    • Si es contravariante, se realiza una inferencia enlazada en el límite superior .If it is contravariant then an upper-bound inference is made.
    • Si es invariable, se realiza una inferencia exacta .If it is invariant then an exact inference is made.

• De lo contrario, no se realiza ninguna inferencia.Otherwise, no inferences are made.

Inferencias de límite superiorUpper-bound inferences

Una inferencia de límite superior de un tipo U a un tipo V se realiza de la siguiente manera:An upper-bound inference from a type U to a type V is made as follows:

• Si V es uno de los desfijos Xi , U se agrega al conjunto de límites superiores para Xi .If V is one of the unfixed Xi then U is added to the set of upper bounds for Xi.

• De lo contrario V1...Vk , U1...Uk los conjuntos y se determinan comprobando si se aplica cualquiera de los casos siguientes:Otherwise, sets V1...Vk and U1...Uk are determined by checking if any of the following cases apply:

  • U es un tipo U1[...] de matriz y V es un tipo V1[...] de matriz del mismo rangoU is an array type U1[...] and V is an array type V1[...] of the same rank

  • U es uno de IEnumerable<Ue> , ICollection<Ue> o IList<Ue> y V es un tipo de matriz unidimensional. Ve[]U is one of IEnumerable<Ue>, ICollection<Ue> or IList<Ue> and V is a one-dimensional array type Ve[]

  • U es el tipo U1? y V es el tipo. V1?U is the type U1? and V is the type V1?

  • U es un tipo de clase, estructura, interfaz o delegado construido C<U1...Uk> y V es una clase, estructura, interfaz o tipo de delegado que es idéntico a, hereda de (directa o indirectamente) o implementa (directa o indirectamente) un tipo único. C<V1...Vk>U is constructed class, struct, interface or delegate type C<U1...Uk> and V is a class, struct, interface or delegate type which is identical to, inherits from (directly or indirectly), or implements (directly or indirectly) a unique type C<V1...Vk>

    (La restricción de unicidad significa que, si tenemos interface C<T>{} class V<Z>: C<X<Z>>, C<Y<Z>>{} , no se realiza ninguna inferencia al deducir de C<U1> a V<Q> .(The "uniqueness" restriction means that if we have interface C<T>{} class V<Z>: C<X<Z>>, C<Y<Z>>{}, then no inference is made when inferring from C<U1> to V<Q>. No se realizan inferencias de U1 en X<Q> ni Y<Q> .)Inferences are not made from U1 to either X<Q> or Y<Q>.)

  Si se aplica cualquiera de estos casos, se realiza una inferencia desde cada Ui hasta el correspondiente, como se indica a continuación Vi :If any of these cases apply then an inference is made from each Ui to the corresponding Vi as follows:

  • Si Ui no se sabe que es un tipo de referencia, se realiza una inferencia exacta .If Ui is not known to be a reference type then an exact inference is made
  • De lo contrario, si V es un tipo de matriz, se realiza una inferencia de límite superior .Otherwise, if V is an array type then an upper-bound inference is made
  • De lo contrario, si U es C<U1...Uk> , la inferencia depende del parámetro de tipo i-ésima de C :Otherwise, if U is C<U1...Uk> then inference depends on the i-th type parameter of C:
    • Si es covariante, se realiza una inferencia enlazada en el límite superior .If it is covariant then an upper-bound inference is made.
    • Si es contravariante, se realiza una inferencia de límite inferior .If it is contravariant then a lower-bound inference is made.
    • Si es invariable, se realiza una inferencia exacta .If it is invariant then an exact inference is made.

• De lo contrario, no se realiza ninguna inferencia.Otherwise, no inferences are made.

Corrección deFixing

Una variable de tipo sin corregir Xi con un conjunto de límites se fija de la manera siguiente:An unfixed type variable Xi with a set of bounds is fixed as follows:

• El conjunto de tipos candidatos Uj comienza como el conjunto de todos los tipos del conjunto de límites para Xi .The set of candidate types Uj starts out as the set of all types in the set of bounds for Xi.
• A continuación, examinaremos cada límite de a Xi su vez: para cada límite exacto U de Xi todos los tipos Uj que no sean idénticos a, U se quitan del conjunto de candidatos.We then examine each bound for Xi in turn: For each exact bound U of Xi all types Uj which are not identical to U are removed from the candidate set. Para cada límite inferior U de Xi todos los tipos Uj a los que no se haya quitado una conversión implícita del U conjunto de candidatos.For each lower bound U of Xi all types Uj to which there is not an implicit conversion from U are removed from the candidate set. Para cada límite superior U de Xi todos los tipos Uj a partir de los cuales no se quita una conversión implícita de en U el conjunto de candidatos.For each upper bound U of Xi all types Uj from which there is not an implicit conversion to U are removed from the candidate set.
• Si entre los tipos de candidatos restantes Uj hay un tipo único V desde el que hay una conversión implícita a todos los demás tipos candidatos, Xi se fija en V .If among the remaining candidate types Uj there is a unique type V from which there is an implicit conversion to all the other candidate types, then Xi is fixed to V.
• De lo contrario, se produce un error en la inferencia de tipos.Otherwise, type inference fails.

Tipo de valor devuelto deducidoInferred return type

El tipo de valor devuelto deducido de una función anónima F se usa durante la inferencia de tipos y la resolución de sobrecarga.The inferred return type of an anonymous function F is used during type inference and overload resolution. El tipo de valor devuelto deducido solo se puede determinar para una función anónima en la que se conocen todos los tipos de parámetro, ya sea porque se proporcionan explícitamente, se proporcionan a través de una conversión de función anónima o se infieren durante la inferencia de tipos en una invocación de método genérico envolvente.The inferred return type can only be determined for an anonymous function where all parameter types are known, either because they are explicitly given, provided through an anonymous function conversion or inferred during type inference on an enclosing generic method invocation.

El tipo de resultado deducido se determina de la siguiente manera:The inferred result type is determined as follows:

• Si el cuerpo de F es una expresión que tiene un tipo, el tipo de resultado deducido de F es el tipo de esa expresión.If the body of F is an expression that has a type, then the inferred result type of F is the type of that expression.
• Si el cuerpo de F es un bloque y el conjunto de expresiones de las instrucciones del bloque return tiene un mejor tipo común T (encontrar el mejor tipo común de un conjunto de expresiones), el tipo de resultado deducido de F es T .If the body of F is a block and the set of expressions in the block's return statements has a best common type T (Finding the best common type of a set of expressions), then the inferred result type of F is T.
• De lo contrario, no se puede inferir un tipo de resultado para F .Otherwise, a result type cannot be inferred for F.

El tipo de valor devuelto deducido se determina de la siguiente manera:The inferred return type is determined as follows:

• Si F es Async y el cuerpo de F es una expresión clasificada como Nothing (clasificación de expresión) o un bloque de instrucciones en el que ninguna instrucción return tiene expresiones, el tipo de valor devuelto deducido es System.Threading.Tasks.TaskIf F is async and the body of F is either an expression classified as nothing (Expression classifications), or a statement block where no return statements have expressions, the inferred return type is System.Threading.Tasks.Task
• Si F es Async y tiene un tipo de resultado deducido T , el tipo de valor devuelto deducido es System.Threading.Tasks.Task<T> .If F is async and has an inferred result type T, the inferred return type is System.Threading.Tasks.Task<T>.
• Si F no es asincrónico y tiene un tipo de resultado deducido T , el tipo de valor devuelto deducido es T .If F is non-async and has an inferred result type T, the inferred return type is T.
• De lo contrario, no se puede inferir un tipo de valor devuelto para F .Otherwise a return type cannot be inferred for F.

Como ejemplo de inferencia de tipos que implica funciones anónimas, tenga en cuenta el Select método de extensión declarado en la System.Linq.Enumerable clase:As an example of type inference involving anonymous functions, consider the Select extension method declared in the System.Linq.Enumerable class:

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TResult> Select<TSource,TResult>(
            this IEnumerable<TSource> source,
            Func<TSource,TResult> selector)
        {
            foreach (TSource element in source) yield return selector(element);
        }
    }
}

Suponiendo que el System.Linq espacio de nombres se importó con una using cláusula y, dada una clase Customer con una Name propiedad de tipo string , el Select método se puede usar para seleccionar los nombres de una lista de clientes:Assuming the System.Linq namespace was imported with a using clause, and given a class Customer with a Name property of type string, the Select method can be used to select the names of a list of customers:

List<Customer> customers = GetCustomerList();
IEnumerable<string> names = customers.Select(c => c.Name);

La invocación del método de extensión (invocaciones de método de extensión) de Select se procesa rescribiendo la invocación a una invocación de método estático:The extension method invocation (Extension method invocations) of Select is processed by rewriting the invocation to a static method invocation:

IEnumerable<string> names = Enumerable.Select(customers, c => c.Name);

Dado que los argumentos de tipo no se especificaron explícitamente, se usa la inferencia de tipos para inferir los argumentos de tipo.Since type arguments were not explicitly specified, type inference is used to infer the type arguments. En primer lugar, el customers argumento está relacionado con el source parámetro, infiriendo T a Customer .First, the customers argument is related to the source parameter, inferring T to be Customer. A continuación, con el proceso de inferencia de tipos de función anónima descrito anteriormente, c se especifica el tipo Customer y la expresión c.Name está relacionada con el tipo de valor devuelto del selector parámetro, infiriendo S a string .Then, using the anonymous function type inference process described above, c is given type Customer, and the expression c.Name is related to the return type of the selector parameter, inferring S to be string. Por lo tanto, la invocación es equivalente aThus, the invocation is equivalent to

Sequence.Select<Customer,string>(customers, (Customer c) => c.Name)

y el resultado es de tipo IEnumerable<string> .and the result is of type IEnumerable<string>.

En el ejemplo siguiente se muestra cómo la inferencia de tipos de función anónima permite la información de tipo para "fluir" entre los argumentos de una invocación de método genérico.The following example demonstrates how anonymous function type inference allows type information to "flow" between arguments in a generic method invocation. Dado el método:Given the method:

static Z F<X,Y,Z>(X value, Func<X,Y> f1, Func<Y,Z> f2) {
    return f2(f1(value));
}

Inferencia de tipos para la invocación:Type inference for the invocation:

double seconds = F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalSeconds);

continúa del modo siguiente: en primer lugar, el argumento "1:15:30" está relacionado con el value parámetro, X que se infiere en string .proceeds as follows: First, the argument "1:15:30" is related to the value parameter, inferring X to be string. A continuación, el parámetro de la primera función anónima, s , recibe el tipo deducido string y la expresión TimeSpan.Parse(s) está relacionada con el tipo de valor devuelto de f1 , infiriendo Y a System.TimeSpan .Then, the parameter of the first anonymous function, s, is given the inferred type string, and the expression TimeSpan.Parse(s) is related to the return type of f1, inferring Y to be System.TimeSpan. Por último, el parámetro de la segunda función anónima, t , recibe el tipo deducido System.TimeSpan y la expresión t.TotalSeconds está relacionada con el tipo de valor devuelto de f2 , infiriendo Z a double .Finally, the parameter of the second anonymous function, t, is given the inferred type System.TimeSpan, and the expression t.TotalSeconds is related to the return type of f2, inferring Z to be double. Por lo tanto, el resultado de la invocación es de tipo double .Thus, the result of the invocation is of type double.

Inferencia de tipos para la conversión de grupos de métodosType inference for conversion of method groups

De forma similar a las llamadas de métodos genéricos, la inferencia de tipos también se debe aplicar cuando un grupo de métodos M que contiene un método genérico se convierte en un tipo de delegado determinado D (conversiones de grupo de métodos).Similar to calls of generic methods, type inference must also be applied when a method group M containing a generic method is converted to a given delegate type D (Method group conversions). Dado un métodoGiven a method

Tr M<X1...Xn>(T1 x1 ... Tm xm)

y el grupo M de métodos que se asigna al tipo de delegado D la tarea de inferencia de tipo es buscar argumentos de tipo para S1...Sn que la expresión:and the method group M being assigned to the delegate type D the task of type inference is to find type arguments S1...Sn so that the expression:

M<S1...Sn>

se convierte en compatible (declaraciones de delegado) con D .becomes compatible (Delegate declarations) with D.

A diferencia del algoritmo de inferencia de tipos para las llamadas de método genérico, en este caso solo hay tipos de argumento, no hay expresiones de argumento.Unlike the type inference algorithm for generic method calls, in this case there are only argument types, no argument expressions. En concreto, no hay ninguna función anónima y, por lo tanto, no es necesario que haya varias fases de inferencia.In particular, there are no anonymous functions and hence no need for multiple phases of inference.

En su lugar, todos Xi se consideran sin corregir y se realiza una inferencia de enlace inferior desde cada tipo Uj de argumento de D al tipo de parámetro correspondiente Tj de M .Instead, all Xi are considered unfixed, and a lower-bound inference is made from each argument type Uj of D to the corresponding parameter type Tj of M. Si no se encuentra ningún Xi límite, se produce un error en la inferencia de tipos.If for any of the Xi no bounds were found, type inference fails. De lo contrario, todos Xi se corrigen en los correspondientes Si , que son el resultado de la inferencia de tipos.Otherwise, all Xi are fixed to corresponding Si, which are the result of type inference.

Buscar el mejor tipo común de un conjunto de expresionesFinding the best common type of a set of expressions

En algunos casos, es necesario inferir un tipo común para un conjunto de expresiones.In some cases, a common type needs to be inferred for a set of expressions. En concreto, los tipos de elemento de matrices con tipo implícito y los tipos de valor devueltos de las funciones anónimas con cuerpos de bloque se encuentran de esta manera.In particular, the element types of implicitly typed arrays and the return types of anonymous functions with block bodies are found in this way.

Intuitivamente, dado un conjunto de expresiones, E1...Em Esta inferencia debe ser equivalente a llamar a un método.Intuitively, given a set of expressions E1...Em this inference should be equivalent to calling a method

Tr M<X>(X x1 ... X xm)

con los Ei argumentos as.with the Ei as arguments.

Más concretamente, la inferencia comienza con una variable de tipo no fija X .More precisely, the inference starts out with an unfixed type variable X. A continuación, se realizan inferencias de tipos de salida de cada Ei a X .Output type inferences are then made from each Ei to X. Por último, X es fijo y, si es correcto, el tipo resultante S es el mejor tipo común resultante para las expresiones.Finally, X is fixed and, if successful, the resulting type S is the resulting best common type for the expressions. Si no S existe, las expresiones no tienen el mejor tipo común.If no such S exists, the expressions have no best common type.

Resolución de sobrecargaOverload resolution

La resolución de sobrecarga es un mecanismo en tiempo de enlace para seleccionar el mejor miembro de función que se va a invocar a partir de una lista de argumentos y un conjunto de miembros de función candidatos.Overload resolution is a binding-time mechanism for selecting the best function member to invoke given an argument list and a set of candidate function members. La resolución de sobrecarga selecciona el miembro de función que se va a invocar en los siguientes contextos distintos dentro de C#:Overload resolution selects the function member to invoke in the following distinct contexts within C#:

• Invocación de un método denominado en un invocation_expression (invocaciones de método).Invocation of a method named in an invocation_expression (Method invocations).
• Invocación de un constructor de instancia denominado en un object_creation_expression (expresiones de creación de objetos).Invocation of an instance constructor named in an object_creation_expression (Object creation expressions).
• Invocación de un descriptor de acceso de indexador a través de un element_access (acceso a elementos).Invocation of an indexer accessor through an element_access (Element access).
• Invocación de un operador predefinido o definido por el usuario al que se hace referencia en una expresión (resolución desobrecarga del operador unario y resolución de sobrecarga del operador binario).Invocation of a predefined or user-defined operator referenced in an expression (Unary operator overload resolution and Binary operator overload resolution).

Cada uno de estos contextos define el conjunto de miembros de función candidatas y la lista de argumentos en su propia manera única, tal como se describe en detalle en las secciones mencionadas anteriormente.Each of these contexts defines the set of candidate function members and the list of arguments in its own unique way, as described in detail in the sections listed above. Por ejemplo, el conjunto de candidatos para una invocación de método no incluye métodos marcados override (búsqueda de miembros) y los métodos de una clase base no son candidatos si algún método de una clase derivada es aplicable (invocaciones de método).For example, the set of candidates for a method invocation does not include methods marked override (Member lookup), and methods in a base class are not candidates if any method in a derived class is applicable (Method invocations).

Una vez identificados los miembros de la función candidata y la lista de argumentos, la selección del mejor miembro de función es la misma en todos los casos:Once the candidate function members and the argument list have been identified, the selection of the best function member is the same in all cases:

• Dado el conjunto de miembros de función candidatos aplicables, se ubica el mejor miembro de función de ese conjunto.Given the set of applicable candidate function members, the best function member in that set is located. Si el conjunto contiene solo un miembro de función, ese miembro de función es el mejor miembro de función.If the set contains only one function member, then that function member is the best function member. De lo contrario, el mejor miembro de función es un miembro de función que es mejor que todos los demás miembros de función con respecto a la lista de argumentos determinada, siempre que cada miembro de función se compare con el resto de miembros de función mediante las reglas de un mejor miembro de función.Otherwise, the best function member is the one function member that is better than all other function members with respect to the given argument list, provided that each function member is compared to all other function members using the rules in Better function member. Si no hay exactamente un miembro de función que sea mejor que todos los demás miembros de función, la invocación del miembro de función es ambigua y se produce un error en tiempo de enlace.If there is not exactly one function member that is better than all other function members, then the function member invocation is ambiguous and a binding-time error occurs.

En las secciones siguientes se definen los significados exactos de los términos * miembro de función aplicable _ y _ mejor miembro de función *.The following sections define the exact meanings of the terms applicable function member _ and _better function member**.

Miembro de función aplicableApplicable function member

Se dice que un miembro de función es un miembro de función aplicable con respecto a una lista A de argumentos cuando se cumplen todas las condiciones siguientes:A function member is said to be an applicable function member with respect to an argument list A when all of the following are true:

• Cada argumento de A corresponde a un parámetro en la declaración de miembro de función tal y como se describe en los parámetros correspondientes, y cualquier parámetro para el que ningún argumento corresponde es un parámetro opcional.Each argument in A corresponds to a parameter in the function member declaration as described in Corresponding parameters, and any parameter to which no argument corresponds is an optional parameter.
• Para cada argumento de A , el modo de paso de parámetros del argumento (es decir, el valor, ref o out ) es idéntico al modo de paso de parámetros del parámetro correspondiente, yFor each argument in A, the parameter passing mode of the argument (i.e., value, ref, or out) is identical to the parameter passing mode of the corresponding parameter, and
  • para un parámetro de valor o una matriz de parámetros, existe una conversión implícita (conversiones implícitas) del argumento al tipo del parámetro correspondiente, o bienfor a value parameter or a parameter array, an implicit conversion (Implicit conversions) exists from the argument to the type of the corresponding parameter, or
  • para un ref out parámetro o, el tipo del argumento es idéntico al tipo del parámetro correspondiente.for a ref or out parameter, the type of the argument is identical to the type of the corresponding parameter. Después de All, ref un out parámetro o es un alias para el argumento pasado.After all, a ref or out parameter is an alias for the argument passed.

Para un miembro de función que incluye una matriz de parámetros, si el miembro de función es aplicable a las reglas anteriores, se dice que es aplicable en su *formulario normal _.For a function member that includes a parameter array, if the function member is applicable by the above rules, it is said to be applicable in its *normal form _. Si un miembro de función que incluye una matriz de parámetros no es aplicable en su forma normal, el miembro de función puede ser aplicable en su forma expandida _ * * *:If a function member that includes a parameter array is not applicable in its normal form, the function member may instead be applicable in its _*expanded form**:

• La forma expandida se construye reemplazando la matriz de parámetros en la declaración de miembro de función con cero o más parámetros de valor del tipo de elemento de la matriz de parámetros de modo que el número de argumentos de la lista de argumentos A coincida con el número total de parámetros.The expanded form is constructed by replacing the parameter array in the function member declaration with zero or more value parameters of the element type of the parameter array such that the number of arguments in the argument list A matches the total number of parameters. Si A tiene menos argumentos que el número de parámetros fijos en la declaración de miembro de función, no se puede construir la forma expandida del miembro de función y, por tanto, no es aplicable.If A has fewer arguments than the number of fixed parameters in the function member declaration, the expanded form of the function member cannot be constructed and is thus not applicable.
• De lo contrario, el formulario expandido es aplicable si para cada argumento del A modo de paso de parámetros del argumento es idéntico al modo de paso de parámetros del parámetro correspondiente, yOtherwise, the expanded form is applicable if for each argument in A the parameter passing mode of the argument is identical to the parameter passing mode of the corresponding parameter, and
  • para un parámetro de valor fijo o un parámetro de valor creado por la expansión, existe una conversión implícita (conversiones implícitas) del tipo del argumento al tipo del parámetro correspondiente, o bienfor a fixed value parameter or a value parameter created by the expansion, an implicit conversion (Implicit conversions) exists from the type of the argument to the type of the corresponding parameter, or
  • para un ref out parámetro o, el tipo del argumento es idéntico al tipo del parámetro correspondiente.for a ref or out parameter, the type of the argument is identical to the type of the corresponding parameter.

Mejor miembro de funciónBetter function member

Con el fin de determinar el mejor miembro de función, se construye una lista de argumentos con la que se ha quitado una lista que contiene solo las expresiones de argumento en el orden en que aparecen en la lista de argumentos original.For the purposes of determining the better function member, a stripped-down argument list A is constructed containing just the argument expressions themselves in the order they appear in the original argument list.

Las listas de parámetros para cada uno de los miembros de la función candidata se construyen de la siguiente manera:Parameter lists for each of the candidate function members are constructed in the following way:

• La forma expandida se utiliza si el miembro de función solo se aplica en el formulario expandido.The expanded form is used if the function member was applicable only in the expanded form.
• Los parámetros opcionales sin argumentos correspondientes se quitan de la lista de parámetrosOptional parameters with no corresponding arguments are removed from the parameter list
• Los parámetros se reordenan para que se produzcan en la misma posición que el argumento correspondiente en la lista de argumentos.The parameters are reordered so that they occur at the same position as the corresponding argument in the argument list.

Dada una lista A de argumentos con un conjunto de expresiones de argumentos {E1, E2, ..., En} y dos miembros de función aplicables Mp y Mq con tipos de parámetros {P1, P2, ..., Pn} y {Q1, Q2, ..., Qn} , Mp se define como un miembro de función mejor que Mq siGiven an argument list A with a set of argument expressions {E1, E2, ..., En} and two applicable function members Mp and Mq with parameter types {P1, P2, ..., Pn} and {Q1, Q2, ..., Qn}, Mp is defined to be a better function member than Mq if

• para cada argumento, la conversión implícita de Ex a Qx no es mejor que la conversión implícita de Ex a Px , yfor each argument, the implicit conversion from Ex to Qx is not better than the implicit conversion from Ex to Px, and
• para al menos un argumento, la conversión de Ex a Px es mejor que la conversión de Ex a Qx .for at least one argument, the conversion from Ex to Px is better than the conversion from Ex to Qx.

Al realizar esta evaluación, si Mp o Mq es aplicable en su forma expandida, Px o Qx hace referencia a un parámetro en la forma expandida de la lista de parámetros.When performing this evaluation, if Mp or Mq is applicable in its expanded form, then Px or Qx refers to a parameter in the expanded form of the parameter list.

En caso de que las secuencias de tipo de parámetro  {P1, P2, ..., Pn} y {Q1, Q2, ..., Qn} sean equivalentes (es decir Pi , cada una tiene una conversión de identidad en la correspondiente Qi ), se aplican las siguientes reglas de separación de desempates, en orden, para determinar el mejor miembro de función.In case the parameter type sequences {P1, P2, ..., Pn} and {Q1, Q2, ..., Qn} are equivalent (i.e. each Pi has an identity conversion to the corresponding Qi), the following tie-breaking rules are applied, in order, to determine the better function member.

• Si Mp es un método no genérico y Mq es un método genérico, Mp es mejor que Mq .If Mp is a non-generic method and Mq is a generic method, then Mp is better than Mq.
• De lo contrario, si Mp es aplicable en su forma normal y Mq tiene una params matriz y solo es aplicable en su forma expandida, Mp es mejor que Mq .Otherwise, if Mp is applicable in its normal form and Mq has a params array and is applicable only in its expanded form, then Mp is better than Mq.
• De lo contrario, si Mp tiene más parámetros declarados que Mq , Mp es mejor que Mq .Otherwise, if Mp has more declared parameters than Mq, then Mp is better than Mq. Esto puede ocurrir si ambos métodos tienen params matrices y solo se pueden aplicar en sus formularios expandidos.This can occur if both methods have params arrays and are applicable only in their expanded forms.
• De lo contrario, si todos los parámetros de Mp tienen un argumento correspondiente, mientras que los argumentos predeterminados deben sustituirse por al menos un parámetro opcional en Mq , entonces Mp es mejor que Mq .Otherwise if all parameters of Mp have a corresponding argument whereas default arguments need to be substituted for at least one optional parameter in Mq then Mp is better than Mq.
• De lo contrario, si Mp tiene tipos de parámetro más específicos que Mq , entonces Mp es mejor que Mq .Otherwise, if Mp has more specific parameter types than Mq, then Mp is better than Mq. Permita {R1, R2, ..., Rn} y {S1, S2, ..., Sn} represente los tipos de parámetro sin instancia y sin expandir de Mp y Mq .Let {R1, R2, ..., Rn} and {S1, S2, ..., Sn} represent the uninstantiated and unexpanded parameter types of Mp and Mq. Mplos tipos de parámetro de son más específicos que Mq si, para cada parámetro, Rx no es menos específico que Sx , y, para al menos un parámetro, Rx es más específico que Sx :Mp's parameter types are more specific than Mq's if, for each parameter, Rx is not less specific than Sx, and, for at least one parameter, Rx is more specific than Sx:
  • Un parámetro de tipo es menos específico que un parámetro sin tipo.A type parameter is less specific than a non-type parameter.
  • De forma recursiva, un tipo construido es más específico que otro tipo construido (con el mismo número de argumentos de tipo) si al menos un argumento de tipo es más específico y ningún argumento de tipo es menos específico que el argumento de tipo correspondiente en el otro.Recursively, a constructed type is more specific than another constructed type (with the same number of type arguments) if at least one type argument is more specific and no type argument is less specific than the corresponding type argument in the other.
  • Un tipo de matriz es más específico que otro tipo de matriz (con el mismo número de dimensiones) si el tipo de elemento del primero es más específico que el tipo de elemento del segundo.An array type is more specific than another array type (with the same number of dimensions) if the element type of the first is more specific than the element type of the second.
• De lo contrario, si un miembro es un operador no de elevación y el otro es un operador de elevación, el valor de uno no elevado es mejor.Otherwise if one member is a non-lifted operator and the other is a lifted operator, the non-lifted one is better.
• De lo contrario, ninguno de los miembros de función es mejor.Otherwise, neither function member is better.

Mejor conversión de la expresiónBetter conversion from expression

Dada una conversión implícita C1 que convierte de una expresión E a un tipo T1 , y una conversión implícita C2 que convierte de una expresión E a un tipo T2 , C1 es una conversión mejor que C2 si E no coincide exactamente con T2 y al menos uno de los siguientes elementos:Given an implicit conversion C1 that converts from an expression E to a type T1, and an implicit conversion C2 that converts from an expression E to a type T2, C1 is a better conversion than C2 if E does not exactly match T2 and at least one of the following holds:

• E coincide exactamente con T1 (expresión de coincidencia exacta)E exactly matches T1 (Exactly matching Expression)
• T1 es un destino de conversión mejor que T2 (mejor destinode la conversión)T1 is a better conversion target than T2 (Better conversion target)

Expresión coincidente exactamenteExactly matching Expression

Dada una expresión E y un tipo T , E coincide exactamente T si uno de los siguientes contiene:Given an expression E and a type T, E exactly matches T if one of the following holds:

• E tiene un tipo S y existe una conversión de identidad de S a TE has a type S, and an identity conversion exists from S to T
• E es una función anónima, T es un tipo de delegado D o un tipo de árbol Expression<D> de expresión y uno de los siguientes elementos contiene:E is an anonymous function, T is either a delegate type D or an expression tree type Expression<D> and one of the following holds:
  • Existe un tipo de valor devuelto deducido X para E en el contexto de la lista de parámetros de D (tipo de valor devuelto deducido) y existe una conversión de identidad de X en el tipo de valor devuelto de DAn inferred return type X exists for E in the context of the parameter list of D (Inferred return type), and an identity conversion exists from X to the return type of D
  • ENo es asincrónico y D tiene un tipo de valor devuelto Y o E es asincrónico y D tiene un tipo de valor devuelto Task<Y> , y una de las siguientes:Either E is non-async and D has a return type Y or E is async and D has a return type Task<Y>, and one of the following holds:
    • El cuerpo de E es una expresión que coincide exactamente con YThe body of E is an expression that exactly matches Y
    • El cuerpo de E es un bloque de instrucciones donde cada instrucción return devuelve una expresión que coincide exactamente con YThe body of E is a statement block where every return statement returns an expression that exactly matches Y

Mejor destino de la conversiónBetter conversion target

Dados dos tipos diferentes T1 y T2 , T1 es un mejor destino de la conversión que T2 si no existe una conversión implícita de T2 a T1 , y al menos uno de los siguientes:Given two different types T1 and T2, T1 is a better conversion target than T2 if no implicit conversion from T2 to T1 exists, and at least one of the following holds:

• Una conversión implícita de T1 a T2 EXISTSAn implicit conversion from T1 to T2 exists
• T1 es un tipo de delegado D1 o un tipo de árbol de expresión Expression<D1> , T2 es un tipo de delegado D2 o un tipo Expression<D2> de árbol de expresión, D1 tiene un tipo de valor devuelto S1 y uno de los siguientes:T1 is either a delegate type D1 or an expression tree type Expression<D1>, T2 is either a delegate type D2 or an expression tree type Expression<D2>, D1 has a return type S1 and one of the following holds:
  • D2 Devuelve voidD2 is void returning
  • D2 tiene un tipo de valor devuelto S2 y S1 es un destino de conversión mejor que S2D2 has a return type S2, and S1 is a better conversion target than S2
• T1 es Task<S1> , T2 es Task<S2> y S1 es un destino de conversión mejor que S2T1 is Task<S1>, T2 is Task<S2>, and S1 is a better conversion target than S2
• T1 es S1 o S1? S1 , donde es un tipo entero con signo y T2 es o, S2 S2? donde S2 es un tipo entero sin signo.T1 is S1 or S1? where S1 is a signed integral type, and T2 is S2 or S2? where S2 is an unsigned integral type. Concretamente:Specifically:
  • S1 es sbyte y S2 es byte , ushort , uint o ulongS1 is sbyte and S2 is byte, ushort, uint, or ulong
  • S1 es short y S2 es ushort , uint o ulongS1 is short and S2 is ushort, uint, or ulong
  • S1 es int y S2 es uint , o ulongS1 is int and S2 is uint, or ulong
  • S1 es long y S2 es ulongS1 is long and S2 is ulong

Sobrecarga en clases genéricasOverloading in generic classes

Mientras que las signaturas declaradas deben ser únicas, es posible que la sustitución de los argumentos de tipo dé como resultado firmas idénticas.While signatures as declared must be unique, it is possible that substitution of type arguments results in identical signatures. En tales casos, las reglas de separación de sobrecargas de la resolución de sobrecarga anterior seleccionarán el miembro más específico.In such cases, the tie-breaking rules of overload resolution above will pick the most specific member.

En los ejemplos siguientes se muestran las sobrecargas válidas y no válidas según esta regla:The following examples show overloads that are valid and invalid according to this rule:

interface I1<T> {...}

interface I2<T> {...}

class G1<U>
{
    int F1(U u);                  // Overload resolution for G<int>.F1
    int F1(int i);                // will pick non-generic

    void F2(I1<U> a);             // Valid overload
    void F2(I2<U> a);
}

class G2<U,V>
{
    void F3(U u, V v);            // Valid, but overload resolution for
    void F3(V v, U u);            // G2<int,int>.F3 will fail

    void F4(U u, I1<V> v);        // Valid, but overload resolution for    
    void F4(I1<V> v, U u);        // G2<I1<int>,int>.F4 will fail

    void F5(U u1, I1<V> v2);      // Valid overload
    void F5(V v1, U u2);

    void F6(ref U u);             // valid overload
    void F6(out V v);
}

Comprobación en tiempo de compilación de la resolución dinámica de sobrecargaCompile-time checking of dynamic overload resolution

Para la mayoría de las operaciones enlazadas dinámicamente, el conjunto de posibles candidatos para la resolución se desconoce en tiempo de compilación.For most dynamically bound operations the set of possible candidates for resolution is unknown at compile-time. En algunos casos, sin embargo, el conjunto de candidatos se conoce en tiempo de compilación:In certain cases, however the candidate set is known at compile-time:

• Llamadas a métodos estáticos con argumentos dinámicosStatic method calls with dynamic arguments
• Llamadas al método de instancia donde el receptor no es una expresión dinámicaInstance method calls where the receiver is not a dynamic expression
• Llamadas de indexador en las que el receptor no es una expresión dinámicaIndexer calls where the receiver is not a dynamic expression
• Llamadas de constructor con argumentos dinámicosConstructor calls with dynamic arguments

En estos casos, se realiza una comprobación limitada en tiempo de compilación para cada candidato a fin de ver si alguna de ellas podría aplicarse en tiempo de ejecución. Esta comprobación consta de los siguientes pasos:In these cases a limited compile-time check is performed for each candidate to see if any of them could possibly apply at run-time.This check consists of the following steps:

• Inferencia de tipos parciales: cualquier argumento de tipo que no dependa directa o indirectamente de un argumento de tipo dynamic se deduce mediante las reglas de inferencia de tipos.Partial type inference: Any type argument that does not depend directly or indirectly on an argument of type dynamic is inferred using the rules of Type inference. Los argumentos de tipo restantes son desconocidos.The remaining type arguments are unknown.
• Comprobación parcial de aplicabilidad: la aplicabilidad se comprueba según el miembro de función aplicable, pero se omiten los parámetros cuyos tipos son desconocidos.Partial applicability check: Applicability is checked according to Applicable function member, but ignoring parameters whose types are unknown.
• Si ningún candidato pasa esta prueba, se produce un error en tiempo de compilación.If no candidate passes this test, a compile-time error occurs.

Invocación de miembros de funciónFunction member invocation

En esta sección se describe el proceso que tiene lugar en tiempo de ejecución para invocar un miembro de función determinado.This section describes the process that takes place at run-time to invoke a particular function member. Se supone que un proceso de tiempo de enlace ya ha determinado el miembro determinado que se va a invocar, posiblemente aplicando la resolución de sobrecarga a un conjunto de miembros de función candidatos.It is assumed that a binding-time process has already determined the particular member to invoke, possibly by applying overload resolution to a set of candidate function members.

Con el fin de describir el proceso de invocación, los miembros de función se dividen en dos categorías:For purposes of describing the invocation process, function members are divided into two categories:

• Miembros de función estáticos.Static function members. Se trata de constructores de instancia, métodos estáticos, descriptores de acceso de propiedades estáticas y operadores definidos por el usuario.These are instance constructors, static methods, static property accessors, and user-defined operators. Los miembros de función estáticos siempre son no virtuales.Static function members are always non-virtual.
• Miembros de función de instancia.Instance function members. Son métodos de instancia, descriptores de acceso de propiedades de instancia y descriptores de acceso de indexador.These are instance methods, instance property accessors, and indexer accessors. Los miembros de la función de instancia son no virtuales o virtuales, y siempre se invocan en una instancia determinada.Instance function members are either non-virtual or virtual, and are always invoked on a particular instance. La instancia se calcula mediante una expresión de instancia y se vuelve accesible dentro del miembro de función como this (este acceso).The instance is computed by an instance expression, and it becomes accessible within the function member as this (This access).

El procesamiento en tiempo de ejecución de una invocación de miembro de función consta de los pasos siguientes, donde M es el miembro de función y, si M es un miembro de instancia, E es la expresión de instancia:The run-time processing of a function member invocation consists of the following steps, where M is the function member and, if M is an instance member, E is the instance expression:

• Si M es un miembro de función estática:If M is a static function member:

  • La lista de argumentos se evalúa como se describe en listas de argumentos.The argument list is evaluated as described in Argument lists.
  • Se invoca a M.M is invoked.

• Si M es un miembro de función de instancia declarado en una value_type:If M is an instance function member declared in a value_type:

  • E se evalúa.E is evaluated. Si esta evaluación provoca una excepción, no se ejecuta ningún paso más.If this evaluation causes an exception, then no further steps are executed.
  • Si E no está clasificado como una variable, se crea una variable local temporal de E tipo y el valor de E se asigna a esa variable.If E is not classified as a variable, then a temporary local variable of E's type is created and the value of E is assigned to that variable. E a continuación, se reclasifica como una referencia a esa variable local temporal.E is then reclassified as a reference to that temporary local variable. La variable temporal es accesible como this en M , pero no de otra manera.The temporary variable is accessible as this within M, but not in any other way. Por lo tanto, solo cuando E es una variable verdadera, el autor de la llamada puede observar los cambios que M realiza en this .Thus, only when E is a true variable is it possible for the caller to observe the changes that M makes to this.
  • La lista de argumentos se evalúa como se describe en listas de argumentos.The argument list is evaluated as described in Argument lists.
  • Se invoca a M.M is invoked. La variable a la que hace referencia E se convierte en la variable a la que hace referencia this .The variable referenced by E becomes the variable referenced by this.

• Si M es un miembro de función de instancia declarado en una reference_type:If M is an instance function member declared in a reference_type:

  • E se evalúa.E is evaluated. Si esta evaluación provoca una excepción, no se ejecuta ningún paso más.If this evaluation causes an exception, then no further steps are executed.
  • La lista de argumentos se evalúa como se describe en listas de argumentos.The argument list is evaluated as described in Argument lists.
  • Si el tipo de E es un value_type, se realiza una conversión boxing (conversiones boxing) para convertir E al tipo object y E se considera que es de tipo object en los pasos siguientes.If the type of E is a value_type, a boxing conversion (Boxing conversions) is performed to convert E to type object, and E is considered to be of type object in the following steps. En este caso, M solo puede ser un miembro de System.Object .In this case, M could only be a member of System.Object.
  • ESe comprueba que el valor de es válido.The value of E is checked to be valid. Si el valor de E es null , System.NullReferenceException se produce una excepción y no se ejecuta ningún paso más.If the value of E is null, a System.NullReferenceException is thrown and no further steps are executed.
  • Se determina la implementación del miembro de función que se va a invocar:The function member implementation to invoke is determined:
    • Si el tipo de tiempo de enlace de E es una interfaz, el miembro de función que se va a invocar es la implementación de M proporcionada por el tipo en tiempo de ejecución de la instancia de a la que hace referencia E .If the binding-time type of E is an interface, the function member to invoke is the implementation of M provided by the run-time type of the instance referenced by E. Este miembro de función se determina aplicando las reglas de asignación de interfaz (asignación de interfaz) para determinar la implementación de M proporcionada por el tipo en tiempo de ejecución de la instancia a la que hace referencia E .This function member is determined by applying the interface mapping rules (Interface mapping) to determine the implementation of M provided by the run-time type of the instance referenced by E.
    • De lo contrario, si M es un miembro de función virtual, el miembro de función que se va a invocar es la implementación de M proporcionada por el tipo en tiempo de ejecución de la instancia a la que hace referencia E .Otherwise, if M is a virtual function member, the function member to invoke is the implementation of M provided by the run-time type of the instance referenced by E. Este miembro de función se determina aplicando las reglas para determinar la implementación más derivada (métodos virtuales) de M con respecto al tipo en tiempo de ejecución de la instancia a la que hace referencia E .This function member is determined by applying the rules for determining the most derived implementation (Virtual methods) of M with respect to the run-time type of the instance referenced by E.
    • De lo contrario, M es un miembro de función no virtual y el miembro de función que se va a invocar es en M sí mismo.Otherwise, M is a non-virtual function member, and the function member to invoke is M itself.
  • Se invoca la implementación de miembro de función determinada en el paso anterior.The function member implementation determined in the step above is invoked. El objeto al que hace referencia E se convierte en el objeto al que hace referencia this .The object referenced by E becomes the object referenced by this.

Invocaciones en instancias de conversión boxingInvocations on boxed instances

Un miembro de función implementado en un value_type se puede invocar a través de una instancia de conversión boxing de que value_type en las situaciones siguientes:A function member implemented in a value_type can be invoked through a boxed instance of that value_type in the following situations:

• Cuando el miembro de función es un override de un método heredado del tipo object y se invoca a través de una expresión de instancia de tipo object .When the function member is an override of a method inherited from type object and is invoked through an instance expression of type object.
• Cuando el miembro de función es una implementación de un miembro de función de interfaz y se invoca a través de una expresión de instancia de un interface_type.When the function member is an implementation of an interface function member and is invoked through an instance expression of an interface_type.
• Cuando el miembro de función se invoca a través de un delegado.When the function member is invoked through a delegate.

En estas situaciones, se considera que la instancia con conversión boxing contiene una variable del value_type y esta variable se convierte en la variable a la que hace referencia this la invocación de miembros de función.In these situations, the boxed instance is considered to contain a variable of the value_type, and this variable becomes the variable referenced by this within the function member invocation. En concreto, esto significa que cuando se invoca un miembro de función en una instancia de conversión boxing, es posible que el miembro de función modifique el valor contenido en la instancia de conversión boxing.In particular, this means that when a function member is invoked on a boxed instance, it is possible for the function member to modify the value contained in the boxed instance.

Expresiones primariasPrimary expressions

Las expresiones primarias incluyen las formas más sencillas de las expresiones.Primary expressions include the simplest forms of expressions.

primary_expression
    : primary_no_array_creation_expression
    | array_creation_expression
    ;

primary_no_array_creation_expression
    : literal
    | interpolated_string_expression
    | simple_name
    | parenthesized_expression
    | member_access
    | invocation_expression
    | element_access
    | this_access
    | base_access
    | post_increment_expression
    | post_decrement_expression
    | object_creation_expression
    | delegate_creation_expression
    | anonymous_object_creation_expression
    | typeof_expression
    | checked_expression
    | unchecked_expression
    | default_value_expression
    | nameof_expression
    | anonymous_method_expression
    | primary_no_array_creation_expression_unsafe
    ;

Las expresiones primarias se dividen entre array_creation_expression s y primary_no_array_creation_expression s.Primary expressions are divided between array_creation_expression s and primary_no_array_creation_expression s. Al tratar la expresión de creación de matrices de esta manera, en lugar de enumerarla junto con las otras formas de expresión simples, permite que la gramática no permita el código potencialmente confuso, comoTreating array-creation-expression in this way, rather than listing it along with the other simple expression forms, enables the grammar to disallow potentially confusing code such as

object o = new int[3][1];

que de otro modo se interpretaría comowhich would otherwise be interpreted as

object o = (new int[3])[1];

LiteralesLiterals

Un primary_expression que consta de un literal (literales) se clasifica como un valor.A primary_expression that consists of a literal (Literals) is classified as a value.

Cadenas interpoladasInterpolated strings

Un interpolated_string_expression consta de un $ signo seguido de un literal de cadena normal o textual, en el que los huecos, delimitados por { y } , escriben expresiones y especificaciones de formato.An interpolated_string_expression consists of a $ sign followed by a regular or verbatim string literal, wherein holes, delimited by { and }, enclose expressions and formatting specifications. Una expresión de cadena interpolada es el resultado de una interpolated_string_literal que se ha dividido en tokens individuales, tal y como se describe en literales de cadena interpolados.An interpolated string expression is the result of an interpolated_string_literal that has been broken up into individual tokens, as described in Interpolated string literals.

interpolated_string_expression
    : '$' interpolated_regular_string
    | '$' interpolated_verbatim_string
    ;

interpolated_regular_string
    : interpolated_regular_string_whole
    | interpolated_regular_string_start interpolated_regular_string_body interpolated_regular_string_end
    ;

interpolated_regular_string_body
    : interpolation (interpolated_regular_string_mid interpolation)*
    ;

interpolation
    : expression
    | expression ',' constant_expression
    ;

interpolated_verbatim_string
    : interpolated_verbatim_string_whole
    | interpolated_verbatim_string_start interpolated_verbatim_string_body interpolated_verbatim_string_end
    ;

interpolated_verbatim_string_body
    : interpolation (interpolated_verbatim_string_mid interpolation)+
    ;

El constant_expression de una interpolación debe tener una conversión implícita a int .The constant_expression in an interpolation must have an implicit conversion to int.

Un interpolated_string_expression se clasifica como un valor.An interpolated_string_expression is classified as a value. Si se convierte inmediatamente en System.IFormattable o System.FormattableString con una conversión de cadena interpolada implícita (conversiones de cadenas interpoladas implícitas), la expresión de cadena interpolada tiene ese tipo.If it is immediately converted to System.IFormattable or System.FormattableString with an implicit interpolated string conversion (Implicit interpolated string conversions), the interpolated string expression has that type. De lo contrario, tiene el tipo string .Otherwise, it has the type string.

Si el tipo de una cadena interpolada es System.IFormattable o System.FormattableString , el significado es una llamada a System.Runtime.CompilerServices.FormattableStringFactory.Create .If the type of an interpolated string is System.IFormattable or System.FormattableString, the meaning is a call to System.Runtime.CompilerServices.FormattableStringFactory.Create. Si el tipo es string , el significado de la expresión es una llamada a string.Format .If the type is string, the meaning of the expression is a call to string.Format. En ambos casos, la lista de argumentos de la llamada consta de un literal de cadena de formato con marcadores de posición para cada interpolación y un argumento para cada expresión correspondiente a los marcadores de posición.In both cases, the argument list of the call consists of a format string literal with placeholders for each interpolation, and an argument for each expression corresponding to the place holders.

El literal de cadena de formato se construye como sigue, donde N es el número de interpolaciones en el interpolated_string_expression:The format string literal is constructed as follows, where N is the number of interpolations in the interpolated_string_expression:

• Si un interpolated_regular_string_whole o un interpolated_verbatim_string_whole siguen el $ signo, el literal de cadena de formato es ese token.If an interpolated_regular_string_whole or an interpolated_verbatim_string_whole follows the $ sign, then the format string literal is that token.
• De lo contrario, el literal de cadena de formato consta de:Otherwise, the format string literal consists of:
  • En primer lugar, interpolated_regular_string_start o interpolated_verbatim_string_startFirst the interpolated_regular_string_start or interpolated_verbatim_string_start
  • A continuación, para cada número I de 0 a N-1 :Then for each number I from 0 to N-1:
    • La representación decimal de IThe decimal representation of I
    • Después, si la interpolación correspondiente tiene una constant_expression, una , (coma) seguida de la representación decimal del valor de la constant_expressionThen, if the corresponding interpolation has a constant_expression, a , (comma) followed by the decimal representation of the value of the constant_expression
    • A continuación, el interpolated_regular_string_mid, interpolated_regular_string_end, interpolated_verbatim_string_mid o interpolated_verbatim_string_end inmediatamente después de la interpolación correspondiente.Then the interpolated_regular_string_mid, interpolated_regular_string_end, interpolated_verbatim_string_mid or interpolated_verbatim_string_end immediately following the corresponding interpolation.

Los argumentos subsiguientes son simplemente las expresiones de las interpolaciones (si existen), en orden.The subsequent arguments are simply the expressions from the interpolations (if any), in order.

TODO: ejemplos.TODO: examples.

Nombres simplesSimple names

Un simple_name consta de un identificador, seguido opcionalmente de una lista de argumentos de tipo:A simple_name consists of an identifier, optionally followed by a type argument list:

simple_name
    : identifier type_argument_list?
    ;

Una simple_name tiene el formato I o el formato I<A1,...,Ak> , donde I es un identificador único y <A1,...,Ak> es un type_argument_list opcional.A simple_name is either of the form I or of the form I<A1,...,Ak>, where I is a single identifier and <A1,...,Ak> is an optional type_argument_list. Si no se especifica ningún type_argument_list , considere la posibilidad K de que sea cero.When no type_argument_list is specified, consider K to be zero. La simple_name se evalúa y se clasifica de la manera siguiente:The simple_name is evaluated and classified as follows:

• Si K es cero y el simple_name aparece dentro de un bloque y el espacio de declaración de variable local del bloque(o el de un bloque de inclusión) contiene una variable local, un parámetro o una constante con el nombre  I , el simple_name hace referencia a esa variable local, parámetro o constante y se clasifica como una variable o valor.If K is zero and the simple_name appears within a block and if the block's (or an enclosing block's) local variable declaration space (Declarations) contains a local variable, parameter or constant with name I, then the simple_name refers to that local variable, parameter or constant and is classified as a variable or value.

• Si K es cero y el simple_name aparece dentro del cuerpo de una declaración de método genérico y la Declaración incluye un parámetro de tipo con el nombre  I , el simple_name hace referencia a ese parámetro de tipo.If K is zero and the simple_name appears within the body of a generic method declaration and if that declaration includes a type parameter with name I, then the simple_name refers to that type parameter.

• De lo contrario, para cada tipo de instancia  T (el tipo de instancia), empezando por el tipo de instancia de la declaración de tipo de inclusión inmediata y continuando con el tipo de instancia de cada declaración de clase o estructura envolvente (si existe):Otherwise, for each instance type T (The instance type), starting with the instance type of the immediately enclosing type declaration and continuing with the instance type of each enclosing class or struct declaration (if any):

  • Si K es cero y la declaración de T incluye un parámetro de tipo con el nombre  I , el simple_name hace referencia a ese parámetro de tipo.If K is zero and the declaration of T includes a type parameter with name I, then the simple_name refers to that type parameter.
  • De lo contrario, si una búsqueda de miembro (búsqueda de miembros) de I in T con argumentos de K   tipo produce una coincidencia:Otherwise, if a member lookup (Member lookup) of I in T with K type arguments produces a match:
    • Si T es el tipo de instancia de la clase o el tipo de estructura de inclusión inmediata y la búsqueda identifica uno o más métodos, el resultado es un grupo de métodos con una expresión de instancia asociada de this .If T is the instance type of the immediately enclosing class or struct type and the lookup identifies one or more methods, the result is a method group with an associated instance expression of this. Si se especificó una lista de argumentos de tipo, se usa para llamar a un método genérico (invocaciones de método).If a type argument list was specified, it is used in calling a generic method (Method invocations).
    • De lo contrario, si T es el tipo de instancia de la clase o el tipo de estructura que se encuentra inmediatamente, si la búsqueda identifica un miembro de instancia, y si la referencia se produce dentro del cuerpo de un constructor de instancia, un método de instancia o un descriptor de acceso de instancia, el resultado es el mismo que un acceso a miembro (acceso a miembros) del formulario this.I .Otherwise, if T is the instance type of the immediately enclosing class or struct type, if the lookup identifies an instance member, and if the reference occurs within the body of an instance constructor, an instance method, or an instance accessor, the result is the same as a member access (Member access) of the form this.I. Esto solo puede ocurrir cuando K es cero.This can only happen when K is zero.
    • De lo contrario, el resultado es el mismo que un acceso a miembro (acceso a miembros) del formulario T.I o T.I<A1,...,Ak> .Otherwise, the result is the same as a member access (Member access) of the form T.I or T.I<A1,...,Ak>. En este caso, es un error en tiempo de enlace para que el simple_name haga referencia a un miembro de instancia.In this case, it is a binding-time error for the simple_name to refer to an instance member.

• De lo contrario, para cada espacio de nombres  N , empezando por el espacio de nombres en el que se produce el simple_name , continuando con cada espacio de nombres envolvente (si existe) y finalizando con el espacio de nombres global, se evalúan los pasos siguientes hasta que se encuentra una entidad:Otherwise, for each namespace N, starting with the namespace in which the simple_name occurs, continuing with each enclosing namespace (if any), and ending with the global namespace, the following steps are evaluated until an entity is located:

  • Si K es cero y I es el nombre de un espacio de nombres en  N , entonces:If K is zero and I is the name of a namespace in N, then:
    • Si la ubicación donde se produce el simple_name se incluye en una declaración de espacio de nombres para N y la declaración del espacio de nombres contiene un extern_alias_directive o using_alias_directive que asocia el nombre  I con un espacio de nombres o un tipo, el simple_name es ambiguo y se produce un error en tiempo de compilación.If the location where the simple_name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with a namespace or type, then the simple_name is ambiguous and a compile-time error occurs.
    • De lo contrario, el simple_name hace referencia al espacio de nombres denominado I en N .Otherwise, the simple_name refers to the namespace named I in N.
  • De lo contrario, si N contiene un tipo accesible con  I parámetros de tipo y nombre K   , entonces:Otherwise, if N contains an accessible type having name I and K type parameters, then:
    • Si K es cero y la ubicación donde se produce el simple_name se incluye en una declaración de espacio de nombres para N y la declaración del espacio de nombres contiene un extern_alias_directive o using_alias_directive que asocia el nombre  I con un espacio de nombres o un tipo, el simple_name es ambiguo y se produce un error en tiempo de compilación.If K is zero and the location where the simple_name occurs is enclosed by a namespace declaration for N and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with a namespace or type, then the simple_name is ambiguous and a compile-time error occurs.
    • De lo contrario, el namespace_or_type_name hace referencia al tipo construido con los argumentos de tipo especificados.Otherwise, the namespace_or_type_name refers to the type constructed with the given type arguments.
  • De lo contrario, si la ubicación donde se produce el simple_name se incluye en una declaración de espacio de nombres para  N :Otherwise, if the location where the simple_name occurs is enclosed by a namespace declaration for N:
    • Si K es cero y la declaración del espacio de nombres contiene un extern_alias_directive o using_alias_directive que asocia el nombre  I con un espacio de nombres o tipo importado, el simple_name hace referencia a ese espacio de nombres o tipo.If K is zero and the namespace declaration contains an extern_alias_directive or using_alias_directive that associates the name I with an imported namespace or type, then the simple_name refers to that namespace or type.
    • De lo contrario, si los espacios de nombres y las declaraciones de tipos importados por using_namespace_directive s y using_static_directive s de la declaración del espacio de nombres contienen exactamente un tipo accesible o un miembro estático que no es de extensión  I K   con parámetros de tipo y nombre, el simple_name hace referencia a ese tipo o miembro construido con los argumentos de tipo especificados.Otherwise, if the namespaces and type declarations imported by the using_namespace_directive s and using_static_directive s of the namespace declaration contain exactly one accessible type or non-extension static member having name I and K type parameters, then the simple_name refers to that type or member constructed with the given type arguments.
    • De lo contrario, si los espacios de nombres y los tipos importados por la using_namespace_directive s de la declaración del espacio de nombres contienen más de un tipo accesible o un miembro estático de método que no es de extensión con  I parámetros de tipo y nombre K   , el simple_name es ambiguo y se produce un error.Otherwise, if the namespaces and types imported by the using_namespace_directive s of the namespace declaration contain more than one accessible type or non-extension-method static member having name I and K type parameters, then the simple_name is ambiguous and an error occurs.

  Tenga en cuenta que todo el paso es exactamente paralelo al paso correspondiente en el procesamiento de un namespace_or_type_name (espacio de nombres y nombres de tipo).Note that this entire step is exactly parallel to the corresponding step in the processing of a namespace_or_type_name (Namespace and type names).

• De lo contrario, el simple_name es indefinido y se produce un error en tiempo de compilación.Otherwise, the simple_name is undefined and a compile-time error occurs.

Expresiones entre paréntesisParenthesized expressions

Un parenthesized_expression consta de una expresión entre paréntesis.A parenthesized_expression consists of an expression enclosed in parentheses.

parenthesized_expression
    : '(' expression ')'
    ;

Un parenthesized_expression se evalúa evaluando la expresión entre paréntesis.A parenthesized_expression is evaluated by evaluating the expression within the parentheses. Si la expresión entre paréntesis denota un espacio de nombres o un tipo, se produce un error en tiempo de compilación.If the expression within the parentheses denotes a namespace or type, a compile-time error occurs. De lo contrario, el resultado de la parenthesized_expression es el resultado de la evaluación de la expresión contenida.Otherwise, the result of the parenthesized_expression is the result of the evaluation of the contained expression.

Acceso a miembrosMember access

Un member_access consta de un primary_expression, un predefined_type o un qualified_alias_member, seguido de un token " . ", seguido de un identificador, seguido opcionalmente de un type_argument_list.A member_access consists of a primary_expression, a predefined_type, or a qualified_alias_member, followed by a "." token, followed by an identifier, optionally followed by a type_argument_list.

member_access
    : primary_expression '.' identifier type_argument_list?
    | predefined_type '.' identifier type_argument_list?
    | qualified_alias_member '.' identifier
    ;

predefined_type
    : 'bool'   | 'byte'  | 'char'  | 'decimal' | 'double' | 'float' | 'int' | 'long'
    | 'object' | 'sbyte' | 'short' | 'string'  | 'uint'   | 'ulong' | 'ushort'
    ;

La qualified_alias_member producción se define en calificadores de alias del espacio de nombres.The qualified_alias_member production is defined in Namespace alias qualifiers.

Una member_access tiene el formato E.I o el formato E.I<A1, ..., Ak> , donde E es una expresión principal, I es un identificador único y <A1, ..., Ak> es un type_argument_list opcional.A member_access is either of the form E.I or of the form E.I<A1, ..., Ak>, where E is a primary-expression, I is a single identifier and <A1, ..., Ak> is an optional type_argument_list. Si no se especifica ningún type_argument_list , considere la posibilidad K de que sea cero.When no type_argument_list is specified, consider K to be zero.

Un member_access con un primary_expression de tipo dynamic está enlazado dinámicamente (enlace dinámico).A member_access with a primary_expression of type dynamic is dynamically bound (Dynamic binding). En este caso, el compilador clasifica el acceso a miembros como un acceso de propiedad de tipo dynamic .In this case the compiler classifies the member access as a property access of type dynamic. A continuación, se aplican las siguientes reglas para determinar el significado de la member_access en tiempo de ejecución, utilizando el tipo en tiempo de ejecución en lugar del tipo en tiempo de compilación del primary_expression.The rules below to determine the meaning of the member_access are then applied at run-time, using the run-time type instead of the compile-time type of the primary_expression. Si esta clasificación en tiempo de ejecución conduce a un grupo de métodos, el acceso a miembros debe ser el primary_expression de un invocation_expression.If this run-time classification leads to a method group, then the member access must be the primary_expression of an invocation_expression.

La member_access se evalúa y se clasifica de la manera siguiente:The member_access is evaluated and classified as follows:

• Si K es cero y E es un espacio de nombres y E contiene un espacio de nombres anidado con el nombre  I , el resultado es dicho espacio de nombres.If K is zero and E is a namespace and E contains a nested namespace with name I, then the result is that namespace.
• De lo contrario, si E es un espacio de nombres y E contiene un tipo accesible  I K   con parámetros de tipo y nombre, el resultado será ese tipo construido con los argumentos de tipo especificados.Otherwise, if E is a namespace and E contains an accessible type having name I and K type parameters, then the result is that type constructed with the given type arguments.
• Si E es un predefined_type o un primary_expression clasificado como un tipo, si E no es un parámetro de tipo y si una búsqueda de miembro (búsqueda de miembros) de I en E con parámetros de K   tipo produce una coincidencia, E.I se evalúa y se clasifica de la manera siguiente:If E is a predefined_type or a primary_expression classified as a type, if E is not a type parameter, and if a member lookup (Member lookup) of I in E with K type parameters produces a match, then E.I is evaluated and classified as follows:
  • Si I identifica un tipo, el resultado es el tipo construido con los argumentos de tipo especificados.If I identifies a type, then the result is that type constructed with the given type arguments.
  • Si I identifica uno o más métodos, el resultado es un grupo de métodos sin expresión de instancia asociada.If I identifies one or more methods, then the result is a method group with no associated instance expression. Si se especificó una lista de argumentos de tipo, se usa para llamar a un método genérico (invocaciones de método).If a type argument list was specified, it is used in calling a generic method (Method invocations).
  • Si I identifica una static propiedad, el resultado es un acceso de propiedad sin expresión de instancia asociada.If I identifies a static property, then the result is a property access with no associated instance expression.
  • Si I identifica un static campo:If I identifies a static field:
    • Si el campo es readonly y la referencia se produce fuera del constructor estático de la clase o estructura en la que se declara el campo, el resultado es un valor, es decir, el valor del campo estático  I de  E .If the field is readonly and the reference occurs outside the static constructor of the class or struct in which the field is declared, then the result is a value, namely the value of the static field I in E.
    • De lo contrario, el resultado es una variable, es decir, el campo estático  I en  E .Otherwise, the result is a variable, namely the static field I in E.
  • Si I identifica un static evento:If I identifies a static event:
    • Si la referencia aparece dentro de la clase o estructura en la que se declara el evento y el evento se declaró sin event_accessor_declarations (eventos), E.I se procesa exactamente como si I fuera un campo estático.If the reference occurs within the class or struct in which the event is declared, and the event was declared without event_accessor_declarations (Events), then E.I is processed exactly as if I were a static field.
    • De lo contrario, el resultado es un acceso de evento sin expresión de instancia asociada.Otherwise, the result is an event access with no associated instance expression.
  • Si I identifica una constante, el resultado es un valor, es decir, el valor de dicha constante.If I identifies a constant, then the result is a value, namely the value of that constant.
  • Si I identifica un miembro de enumeración, el resultado es un valor, es decir, el valor de ese miembro de la enumeración.If I identifies an enumeration member, then the result is a value, namely the value of that enumeration member.
  • De lo contrario, E.I es una referencia de miembro no válida y se produce un error en tiempo de compilación.Otherwise, E.I is an invalid member reference, and a compile-time error occurs.
• Si E es un acceso de propiedad, un acceso de indexador, una variable o un valor, cuyo tipo es  T , y una búsqueda de miembro (búsqueda de miembros) de I en T con argumentos de K   tipo produce una coincidencia, E.I se evalúa y se clasifica de la manera siguiente:If E is a property access, indexer access, variable, or value, the type of which is T, and a member lookup (Member lookup) of I in T with K type arguments produces a match, then E.I is evaluated and classified as follows:
  • En primer lugar, si E es un acceso de propiedad o indizador, se obtiene el valor de la propiedad o el acceso del indexador (valores de las expresiones) y E se reclasifica como un valor.First, if E is a property or indexer access, then the value of the property or indexer access is obtained (Values of expressions) and E is reclassified as a value.
  • Si I identifica uno o más métodos, el resultado es un grupo de métodos con una expresión de instancia asociada de E .If I identifies one or more methods, then the result is a method group with an associated instance expression of E. Si se especificó una lista de argumentos de tipo, se usa para llamar a un método genérico (invocaciones de método).If a type argument list was specified, it is used in calling a generic method (Method invocations).
  • Si I identifica una propiedad de instancia,If I identifies an instance property,
    • Si E es this , I identifica una propiedad implementada automáticamente (propiedades implementadas automáticamente) sin un establecedor y la referencia se produce dentro de un constructor de instancia para un tipo de clase o struct T , el resultado es una variable, es decir, el campo de respaldo oculto para la propiedad automática proporcionada por I en la instancia de T proporcionada por this .If E is this, I identifies an automatically implemented property (Automatically implemented properties) without a setter, and the reference occurs within an instance constructor for a class or struct type T, then the result is a variable, namely the hidden backing field for the auto-property given by I in the instance of T given by this.
    • De lo contrario, el resultado es un acceso de propiedad con una expresión de instancia asociada de  E .Otherwise, the result is a property access with an associated instance expression of E.
  • Si T es un class_type e I identifica un campo de instancia de que class_type:If T is a class_type and I identifies an instance field of that class_type:
    • Si el valor de E es null , System.NullReferenceException se produce una excepción.If the value of E is null, then a System.NullReferenceException is thrown.
    • De lo contrario, si el campo es readonly y la referencia se produce fuera de un constructor de instancia de la clase en la que se declara el campo, el resultado es un valor, es decir, el valor del campo  I en el objeto al que hace referencia  E .Otherwise, if the field is readonly and the reference occurs outside an instance constructor of the class in which the field is declared, then the result is a value, namely the value of the field I in the object referenced by E.
    • De lo contrario, el resultado es una variable, es decir, el campo del  I objeto al que hace referencia  E .Otherwise, the result is a variable, namely the field I in the object referenced by E.
  • Si T es un struct_type e I identifica un campo de instancia de que struct_type:If T is a struct_type and I identifies an instance field of that struct_type:
    • Si E es un valor, o si el campo es readonly y la referencia se produce fuera de un constructor de instancia de la estructura en la que se declara el campo, el resultado es un valor, es decir, el valor del campo  I en la instancia de la estructura especificada por  E .If E is a value, or if the field is readonly and the reference occurs outside an instance constructor of the struct in which the field is declared, then the result is a value, namely the value of the field I in the struct instance given by E.
    • De lo contrario, el resultado es una variable, es decir, el campo  I de la instancia de struct proporcionado por  E .Otherwise, the result is a variable, namely the field I in the struct instance given by E.
  • Si I identifica un evento de instancia:If I identifies an instance event:
    • Si la referencia se produce dentro de la clase o estructura en la que se declara el evento y el evento se declaró sin event_accessor_declarations (eventos), y la referencia no se produce como el lado izquierdo de un += -= operador OR, E.I se procesa exactamente como si I fuera un campo de instancia.If the reference occurs within the class or struct in which the event is declared, and the event was declared without event_accessor_declarations (Events), and the reference does not occur as the left-hand side of a += or -= operator, then E.I is processed exactly as if I was an instance field.
    • De lo contrario, el resultado es un evento de acceso con una expresión de instancia asociada de  E .Otherwise, the result is an event access with an associated instance expression of E.
• De lo contrario, se intenta procesar E.I como una invocación de método de extensión (invocaciones de método de extensión).Otherwise, an attempt is made to process E.I as an extension method invocation (Extension method invocations). Si se produce un error, E.I es una referencia de miembro no válida y se produce un error en tiempo de enlace.If this fails, E.I is an invalid member reference, and a binding-time error occurs.

Nombres simples y nombres de tipo idénticosIdentical simple names and type names

En un acceso de miembro del formulario E.I , si E es un identificador único, y si el significado de E como simple_name (nombres simples) es una constante, un campo, una propiedad, una variable local o un parámetro con el mismo tipo que el significado de E como type_name (espacio de nombres y nombres de tipo), se permiten ambos significados posibles E .In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple_name (Simple names) is a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type_name (Namespace and type names), then both possible meanings of E are permitted. Los dos significados posibles de E.I nunca son ambiguos, ya que I debe ser necesariamente miembro del tipo E en ambos casos.The two possible meanings of E.I are never ambiguous, since I must necessarily be a member of the type E in both cases. En otras palabras, la regla simplemente permite el acceso a los miembros estáticos y los tipos anidados E en los que, de lo contrario, se produciría un error en tiempo de compilación.In other words, the rule simply permits access to the static members and nested types of E where a compile-time error would otherwise have occurred. Por ejemplo:For example:

struct Color
{
    public static readonly Color White = new Color(...);
    public static readonly Color Black = new Color(...);

    public Color Complement() {...}
}

class A
{
    public Color Color;                // Field Color of type Color

    void F() {
        Color = Color.Black;           // References Color.Black static member
        Color = Color.Complement();    // Invokes Complement() on Color field
    }

    static void G() {
        Color c = Color.White;         // References Color.White static member
    }
}

Ambigüedades de la gramáticaGrammar ambiguities

Las producciones de simple_name (nombres simples) y member_access (acceso a miembros) pueden dar lugar a ambigüedades en la gramática de expresiones.The productions for simple_name (Simple names) and member_access (Member access) can give rise to ambiguities in the grammar for expressions. Por ejemplo, la instrucción:For example, the statement:

F(G<A,B>(7));

podría interpretarse como una llamada a F con dos argumentos, G < A y B > (7) .could be interpreted as a call to F with two arguments, G < A and B > (7). Como alternativa, podría interpretarse como una llamada a F con un argumento, que es una llamada a un método genérico  G con dos argumentos de tipo y un argumento normal.Alternatively, it could be interpreted as a call to F with one argument, which is a call to a generic method G with two type arguments and one regular argument.

Si se puede analizar una secuencia de tokens (en contexto) como simple_name (nombres simples), member_access (acceso a miembros) o pointer_member_access (acceso a miembros de puntero) que finaliza con un type_argument_list (argumentos de tipo), se examina el token inmediatamente posterior al token de cierre > .If a sequence of tokens can be parsed (in context) as a simple_name (Simple names), member_access (Member access), or pointer_member_access (Pointer member access) ending with a type_argument_list (Type arguments), the token immediately following the closing > token is examined. Si es uno deIf it is one of

(  )  ]  }  :  ;  ,  .  ?  ==  !=  |  ^

a continuación, el type_argument_list se conserva como parte del simple_name, member_access o pointer_member_access y se descarta cualquier otro posible análisis de la secuencia de tokens.then the type_argument_list is retained as part of the simple_name, member_access or pointer_member_access and any other possible parse of the sequence of tokens is discarded. De lo contrario, el type_argument_list no se considera parte de la simple_name, member_access o pointer_member_access, aunque no haya ningún otro análisis posible de la secuencia de tokens.Otherwise, the type_argument_list is not considered to be part of the simple_name, member_access or pointer_member_access, even if there is no other possible parse of the sequence of tokens. Tenga en cuenta que estas reglas no se aplican al analizar una type_argument_list en un namespace_or_type_name (espacio de nombres y nombres de tipo).Note that these rules are not applied when parsing a type_argument_list in a namespace_or_type_name (Namespace and type names). La instrucciónThe statement

F(G<A,B>(7));

, según esta regla, se interpretará como una llamada a F con un argumento, que es una llamada a un método genérico G con dos argumentos de tipo y un argumento normal.will, according to this rule, be interpreted as a call to F with one argument, which is a call to a generic method G with two type arguments and one regular argument. Las instruccionesThe statements

F(G < A, B > 7);
F(G < A, B >> 7);

cada uno de ellos se interpretará como una llamada a F con dos argumentos.will each be interpreted as a call to F with two arguments. La instrucciónThe statement

x = F < A > +y;

se interpretará como un operador menor que, mayor que y unario más, como si se hubiera escrito la instrucción x = (F < A) > (+y) , en lugar de un simple_name con un type_argument_list seguido de un operador binario Plus.will be interpreted as a less than operator, greater than operator, and unary plus operator, as if the statement had been written x = (F < A) > (+y), instead of as a simple_name with a type_argument_list followed by a binary plus operator. En la instrucciónIn the statement

x = y is C<T> + z;

los tokens C<T> se interpretan como un namespace_or_type_name con un type_argument_list.the tokens C<T> are interpreted as a namespace_or_type_name with a type_argument_list.

Expresiones de invocaciónInvocation expressions

Un invocation_expression se utiliza para invocar un método.An invocation_expression is used to invoke a method.

invocation_expression
    : primary_expression '(' argument_list? ')'
    ;

Un invocation_expression está enlazado dinámicamente (enlace dinámico) si al menos uno de los siguientes contiene:An invocation_expression is dynamically bound (Dynamic binding) if at least one of the following holds:

• El primary_expression tiene el tipo en tiempo de compilación dynamic .The primary_expression has compile-time type dynamic.
• Al menos un argumento del argument_list opcional tiene el tipo en tiempo de compilación dynamic y el primary_expression no tiene un tipo de delegado.At least one argument of the optional argument_list has compile-time type dynamic and the primary_expression does not have a delegate type.

En este caso, el compilador clasifica el invocation_expression como un valor de tipo dynamic .In this case the compiler classifies the invocation_expression as a value of type dynamic. A continuación, se aplican las siguientes reglas para determinar el significado de la invocation_expression en tiempo de ejecución, utilizando el tipo en tiempo de ejecución en lugar del tipo en tiempo de compilación de los primary_expression y argumentos que tienen el tipo en tiempo de compilación dynamic .The rules below to determine the meaning of the invocation_expression are then applied at run-time, using the run-time type instead of the compile-time type of those of the primary_expression and arguments which have the compile-time type dynamic. Si el primary_expression no tiene el tipo en tiempo de compilación dynamic , la invocación del método sufre una comprobación limitada del tiempo de compilación, como se describe en comprobación en tiempo de compilación de la resolución de sobrecarga dinámica.If the primary_expression does not have compile-time type dynamic, then the method invocation undergoes a limited compile time check as described in Compile-time checking of dynamic overload resolution.

El primary_expression de una invocation_expression debe ser un grupo de métodos o un valor de un delegate_type.The primary_expression of an invocation_expression must be a method group or a value of a delegate_type. Si el primary_expression es un grupo de métodos, el invocation_expression es una invocación de método (invocaciones de método).If the primary_expression is a method group, the invocation_expression is a method invocation (Method invocations). Si el primary_expression es un valor de un delegate_type, el invocation_expression es una invocación de delegado (invocaciones de delegado).If the primary_expression is a value of a delegate_type, the invocation_expression is a delegate invocation (Delegate invocations). Si el primary_expression no es un grupo de métodos ni un valor de un delegate_type, se produce un error en tiempo de enlace.If the primary_expression is neither a method group nor a value of a delegate_type, a binding-time error occurs.

El argument_list opcional (listas de argumentos) proporciona valores o referencias a variables para los parámetros del método.The optional argument_list (Argument lists) provides values or variable references for the parameters of the method.

El resultado de evaluar una invocation_expression se clasifica como sigue:The result of evaluating an invocation_expression is classified as follows:

• Si el invocation_expression invoca un método o un delegado que devuelve void , el resultado es Nothing.If the invocation_expression invokes a method or delegate that returns void, the result is nothing. Una expresión que se clasifique como Nothing solo se permite en el contexto de una statement_expression (instrucciones de expresión) o como el cuerpo de un lambda_expression (expresiones de función anónima).An expression that is classified as nothing is permitted only in the context of a statement_expression (Expression statements) or as the body of a lambda_expression (Anonymous function expressions). En caso contrario, se produce un error en tiempo de enlace.Otherwise a binding-time error occurs.
• De lo contrario, el resultado es un valor del tipo devuelto por el método o el delegado.Otherwise, the result is a value of the type returned by the method or delegate.

Invocaciones de métodoMethod invocations

En el caso de una invocación de método, el primary_expression de la invocation_expression debe ser un grupo de métodos.For a method invocation, the primary_expression of the invocation_expression must be a method group. El grupo de métodos identifica el método que se va a invocar o el conjunto de métodos sobrecargados desde los que se va a elegir un método específico que se va a invocar.The method group identifies the one method to invoke or the set of overloaded methods from which to choose a specific method to invoke. En el último caso, la determinación del método específico que se va a invocar se basa en el contexto proporcionado por los tipos de los argumentos en el argument_list.In the latter case, determination of the specific method to invoke is based on the context provided by the types of the arguments in the argument_list.

El procesamiento en tiempo de enlace de una invocación de método con el formato M(A) , donde M es un grupo de métodos (posiblemente incluido un type_argument_list) y A es un argument_list opcional, consta de los siguientes pasos:The binding-time processing of a method invocation of the form M(A), where M is a method group (possibly including a type_argument_list), and A is an optional argument_list, consists of the following steps:

• Se construye el conjunto de métodos candidatos para la invocación del método.The set of candidate methods for the method invocation is constructed. Para cada método F asociado al grupo de métodos M :For each method F associated with the method group M:
  • Si F no es genérico, F es un candidato cuando:If F is non-generic, F is a candidate when:
    • M no tiene ninguna lista de argumentos de tipo yM has no type argument list, and
    • F es aplicable con respecto a A (miembro de función aplicable).F is applicable with respect to A (Applicable function member).
  • Si F es genérico y M no tiene ninguna lista de argumentos de tipo, F es un candidato cuando:If F is generic and M has no type argument list, F is a candidate when:
    • La inferencia de tipos (inferencia de tipo) se realiza correctamente, deduciendo una lista de argumentos de tipo para la llamada yType inference (Type inference) succeeds, inferring a list of type arguments for the call, and
    • Una vez que los argumentos de tipo deducido se sustituyen por los parámetros de tipo de método correspondientes, todos los tipos construidos en la lista de parámetros de F satisfacen sus restricciones (quecumplencon las restricciones) y la lista de parámetros de F es aplicable con respecto a A (miembro defunción aplicable).Once the inferred type arguments are substituted for the corresponding method type parameters, all constructed types in the parameter list of F satisfy their constraints (Satisfying constraints), and the parameter list of F is applicable with respect to A (Applicable function member).
  • Si F es genérico e M incluye una lista de argumentos de tipo, F es un candidato cuando:If F is generic and M includes a type argument list, F is a candidate when:
    • F tiene el mismo número de parámetros de tipo de método que se proporcionaron en la lista de argumentos de tipo yF has the same number of method type parameters as were supplied in the type argument list, and
    • Una vez que los argumentos de tipo se sustituyen por los parámetros de tipo de método correspondientes, todos los tipos construidos en la lista de parámetros de F satisfacen sus restricciones (quecumplencon las restricciones) y la lista de parámetros de F es aplicable con respecto a A (miembro defunción aplicable).Once the type arguments are substituted for the corresponding method type parameters, all constructed types in the parameter list of F satisfy their constraints (Satisfying constraints), and the parameter list of F is applicable with respect to A (Applicable function member).
• El conjunto de métodos candidatos se reduce para que solo contengan métodos de los tipos más derivados: para cada método del C.F conjunto, donde C es el tipo en el que F se declara el método, todos los métodos declarados en un tipo base de C se quitan del conjunto.The set of candidate methods is reduced to contain only methods from the most derived types: For each method C.F in the set, where C is the type in which the method F is declared, all methods declared in a base type of C are removed from the set. Además, si C es un tipo de clase distinto de object , todos los métodos declarados en un tipo de interfaz se quitan del conjunto.Furthermore, if C is a class type other than object, all methods declared in an interface type are removed from the set. (Esta última regla solo tiene efecto cuando el grupo de métodos era el resultado de una búsqueda de miembros en un parámetro de tipo que tiene una clase base efectiva que no es un objeto y un conjunto de interfaces efectivo no vacío).(This latter rule only has affect when the method group was the result of a member lookup on a type parameter having an effective base class other than object and a non-empty effective interface set.)
• Si el conjunto resultante de métodos candidatos está vacío, se abandona el procesamiento posterior a lo largo de los pasos siguientes y, en su lugar, se intenta procesar la invocación como una invocación de método de extensión (invocaciones de método de extensión).If the resulting set of candidate methods is empty, then further processing along the following steps are abandoned, and instead an attempt is made to process the invocation as an extension method invocation (Extension method invocations). Si se produce un error, no existe ningún método aplicable y se produce un error en tiempo de enlace.If this fails, then no applicable methods exist, and a binding-time error occurs.
• El mejor método del conjunto de métodos candidatos se identifica mediante las reglas de resolución de sobrecarga de la resolución de sobrecarga.The best method of the set of candidate methods is identified using the overload resolution rules of Overload resolution. Si no se puede identificar un único método mejor, la invocación del método es ambigua y se produce un error en tiempo de enlace.If a single best method cannot be identified, the method invocation is ambiguous, and a binding-time error occurs. Al realizar la resolución de sobrecarga, los parámetros de un método genérico se tienen en cuenta después de sustituir los argumentos de tipo (proporcionados o deducidos) para los parámetros de tipo de método correspondientes.When performing overload resolution, the parameters of a generic method are considered after substituting the type arguments (supplied or inferred) for the corresponding method type parameters.
• Se realiza la validación final del mejor método elegido:Final validation of the chosen best method is performed:
  • El método se valida en el contexto del grupo de métodos: Si el mejor método es un método estático, el grupo de métodos debe haber sido el resultado de un simple_name o de un member_access a través de un tipo.The method is validated in the context of the method group: If the best method is a static method, the method group must have resulted from a simple_name or a member_access through a type. Si el mejor método es un método de instancia, el grupo de métodos debe haber sido el resultado de un simple_name, un member_access a través de una variable o un valor, o un base_access.If the best method is an instance method, the method group must have resulted from a simple_name, a member_access through a variable or value, or a base_access. Si ninguno de estos requisitos es true, se produce un error en tiempo de enlace.If neither of these requirements is true, a binding-time error occurs.
  • Si el mejor método es un método genérico, los argumentos de tipo (suministrados o deducidos) se comprueban con las restricciones (quecumplen las restricciones) declaradas en el método genérico.If the best method is a generic method, the type arguments (supplied or inferred) are checked against the constraints (Satisfying constraints) declared on the generic method. Si algún argumento de tipo no satisface las restricciones correspondientes en el parámetro de tipo, se produce un error en tiempo de enlace.If any type argument does not satisfy the corresponding constraint(s) on the type parameter, a binding-time error occurs.

Una vez que se ha seleccionado y validado un método en tiempo de enlace según los pasos anteriores, la invocación real en tiempo de ejecución se procesa de acuerdo con las reglas de invocación de miembros de función descritas en la comprobación en tiempo de compilación de la resolución dinámica de sobrecarga.Once a method has been selected and validated at binding-time by the above steps, the actual run-time invocation is processed according to the rules of function member invocation described in Compile-time checking of dynamic overload resolution.

El efecto intuitivo de las reglas de resolución descritas anteriormente es el siguiente: para encontrar el método determinado invocado por una invocación de método, empiece con el tipo indicado por la invocación del método y continúe con la cadena de herencia hasta que se encuentre al menos una declaración de método aplicable, accesible y que no sea de invalidación.The intuitive effect of the resolution rules described above is as follows: To locate the particular method invoked by a method invocation, start with the type indicated by the method invocation and proceed up the inheritance chain until at least one applicable, accessible, non-override method declaration is found. A continuación, realice la inferencia de tipos y la resolución de sobrecarga en el conjunto de métodos aplicables, accesibles y no invalidaciones declarados en ese tipo e invoque el método de la forma que se seleccione.Then perform type inference and overload resolution on the set of applicable, accessible, non-override methods declared in that type and invoke the method thus selected. Si no se encuentra ningún método, pruebe en su lugar para procesar la invocación como una invocación de método de extensión.If no method was found, try instead to process the invocation as an extension method invocation.

Invocaciones de métodos de extensiónExtension method invocations

En una invocación de método (invocaciones en instancias de conversión boxing) de uno de los formulariosIn a method invocation (Invocations on boxed instances) of one of the forms

expr . identifier ( )

expr . identifier ( args )

expr . identifier < typeargs > ( )

expr . identifier < typeargs > ( args )

Si el procesamiento normal de la invocación no encuentra ningún método aplicable, se realiza un intento de procesar la construcción como una invocación de método de extensión.if the normal processing of the invocation finds no applicable methods, an attempt is made to process the construct as an extension method invocation. Si expr o cualquiera de los argumentos tiene el tipo en tiempo de compilación dynamic , los métodos de extensión no se aplicarán.If expr or any of the args has compile-time type dynamic, extension methods will not apply.

El objetivo es encontrar el mejor type_name C , de modo que pueda tener lugar la invocación de método estático correspondiente:The objective is to find the best type_name C, so that the corresponding static method invocation can take place:

C . identifier ( expr )

C . identifier ( expr , args )

C . identifier < typeargs > ( expr )

C . identifier < typeargs > ( expr , args )

Un método de extensión Ci.Mj es válido si:An extension method Ci.Mj is eligible if:

• Ci es una clase no genérica y no anidadaCi is a non-generic, non-nested class
• El nombre de Mj es IdentifierThe name of Mj is identifier
• Mj es accesible y aplicable cuando se aplica a los argumentos como un método estático, como se muestra arriba.Mj is accessible and applicable when applied to the arguments as a static method as shown above
• Existe una conversión implícita de identidad, de referencia o de conversión boxing de expr al tipo del primer parámetro de Mj .An implicit identity, reference or boxing conversion exists from expr to the type of the first parameter of Mj.

La búsqueda de C continúa como sigue:The search for C proceeds as follows:

• A partir de la declaración de espacio de nombres envolvente más cercana, continuando con cada declaración de espacio de nombres envolvente y finalizando con la unidad de compilación que lo contiene, se realizan sucesivos intentos para buscar un conjunto candidato de métodos de extensión:Starting with the closest enclosing namespace declaration, continuing with each enclosing namespace declaration, and ending with the containing compilation unit, successive attempts are made to find a candidate set of extension methods:
  • Si el espacio de nombres o la unidad de compilación especificados contiene directamente declaraciones de tipos no genéricos Ci con métodos de extensión válidos Mj , el conjunto de estos métodos de extensión es el conjunto de candidatos.If the given namespace or compilation unit directly contains non-generic type declarations Ci with eligible extension methods Mj, then the set of those extension methods is the candidate set.
  • Si los tipos Ci importados por using_static_declarations y que se declaran directamente en los espacios de nombres importados por using_namespace_directive s en el espacio de nombres o la unidad de compilación especificados directamente contienen métodos de extensión válidos Mj , el conjunto de estos métodos de extensión es el conjunto de candidatos.If types Ci imported by using_static_declarations and directly declared in namespaces imported by using_namespace_directive s in the given namespace or compilation unit directly contain eligible extension methods Mj, then the set of those extension methods is the candidate set.
• Si no se encuentra ningún conjunto candidato en ninguna declaración de espacio de nombres envolvente o unidad de compilación, se produce un error en tiempo de compilación.If no candidate set is found in any enclosing namespace declaration or compilation unit, a compile-time error occurs.
• De lo contrario, se aplica la resolución de sobrecarga al conjunto de candidatos tal y como se describe en (resolución de sobrecarga).Otherwise, overload resolution is applied to the candidate set as described in (Overload resolution). Si no se encuentra ningún método mejor, se produce un error en tiempo de compilación.If no single best method is found, a compile-time error occurs.
• C es el tipo en el que se declara el mejor método como método de extensión.C is the type within which the best method is declared as an extension method.

Con C como destino, la llamada al método se procesa a continuación como una invocación de método estático (comprobación en tiempo de compilación de la resolución dinámica de sobrecarga).Using C as a target, the method call is then processed as a static method invocation (Compile-time checking of dynamic overload resolution).

Las reglas anteriores implican que los métodos de instancia tienen prioridad sobre los métodos de extensión, que los métodos de extensión disponibles en las declaraciones de espacios de nombres internos tienen prioridad sobre los métodos de extensión disponibles en las declaraciones de espacios de nombres exteriores y que los métodos de extensión declarados directamente en un espacio de nombres tienen prioridad sobre los métodos de extensión importados en el mismo espacio de nombres con una directivaThe preceding rules mean that instance methods take precedence over extension methods, that extension methods available in inner namespace declarations take precedence over extension methods available in outer namespace declarations, and that extension methods declared directly in a namespace take precedence over extension methods imported into that same namespace with a using namespace directive. Por ejemplo:For example:

public static class E
{
    public static void F(this object obj, int i) { }

    public static void F(this object obj, string s) { }
}

class A { }

class B
{
    public void F(int i) { }
}

class C
{
    public void F(object obj) { }
}

class X
{
    static void Test(A a, B b, C c) {
        a.F(1);              // E.F(object, int)
        a.F("hello");        // E.F(object, string)

        b.F(1);              // B.F(int)
        b.F("hello");        // E.F(object, string)

        c.F(1);              // C.F(object)
        c.F("hello");        // C.F(object)
    }
}

En el ejemplo, el B método de tiene prioridad sobre el primer método de extensión y el C método de tiene prioridad sobre ambos métodos de extensión.In the example, B's method takes precedence over the first extension method, and C's method takes precedence over both extension methods.

public static class C
{
    public static void F(this int i) { Console.WriteLine("C.F({0})", i); }
    public static void G(this int i) { Console.WriteLine("C.G({0})", i); }
    public static void H(this int i) { Console.WriteLine("C.H({0})", i); }
}

namespace N1
{
    public static class D
    {
        public static void F(this int i) { Console.WriteLine("D.F({0})", i); }
        public static void G(this int i) { Console.WriteLine("D.G({0})", i); }
    }
}

namespace N2
{
    using N1;

    public static class E
    {
        public static void F(this int i) { Console.WriteLine("E.F({0})", i); }
    }

    class Test
    {
        static void Main(string[] args)
        {
            1.F();
            2.G();
            3.H();
        }
    }
}

El resultado de este ejemplo es:The output of this example is:

E.F(1)
D.G(2)
C.H(3)

D.G tiene prioridad sobre y C.G E.F tiene prioridad sobre D.F y C.F .D.G takes precedence over C.G, and E.F takes precedence over both D.F and C.F.

Invocaciones de delegadoDelegate invocations

En el caso de una invocación de delegado, el primary_expression de la invocation_expression debe ser un valor de un delegate_type.For a delegate invocation, the primary_expression of the invocation_expression must be a value of a delegate_type. Además, si se considera que el delegate_type ser un miembro de función con la misma lista de parámetros que el delegate_type, el delegate_type debe ser aplicable (miembro de función aplicable) con respecto al argument_list del invocation_expression.Furthermore, considering the delegate_type to be a function member with the same parameter list as the delegate_type, the delegate_type must be applicable (Applicable function member) with respect to the argument_list of the invocation_expression.

El procesamiento en tiempo de ejecución de una invocación de delegado con el formato D(A) , donde D es una primary_expression de un delegate_type y A es un argument_list opcional, consta de los siguientes pasos:The run-time processing of a delegate invocation of the form D(A), where D is a primary_expression of a delegate_type and A is an optional argument_list, consists of the following steps:

• D se evalúa.D is evaluated. Si esta evaluación provoca una excepción, no se ejecuta ningún paso más.If this evaluation causes an exception, no further steps are executed.
• DSe comprueba que el valor de es válido.The value of D is checked to be valid. Si el valor de D es null , System.NullReferenceException se produce una excepción y no se ejecuta ningún paso más.If the value of D is null, a System.NullReferenceException is thrown and no further steps are executed.
• De lo contrario, D es una referencia a una instancia de delegado.Otherwise, D is a reference to a delegate instance. Las invocaciones de miembros de función (comprobación en tiempo de compilación de la resolución dinámica de sobrecarga) se realizan en cada una de las entidades a las que se puede llamar en la lista de invocaciones del delegado.Function member invocations (Compile-time checking of dynamic overload resolution) are performed on each of the callable entities in the invocation list of the delegate. Para las entidades a las que se puede llamar que se componen de un método de instancia y de instancia, la instancia de para la invocación es la instancia contenida en la entidad a la que se puedeFor callable entities consisting of an instance and instance method, the instance for the invocation is the instance contained in the callable entity.

Acceso a elementosElement access

Un element_access consta de un primary_no_array_creation_expression, seguido de un [ token "", seguido de un argument_list, seguido de un ] token "".An element_access consists of a primary_no_array_creation_expression, followed by a "[" token, followed by an argument_list, followed by a "]" token. El argument_list se compone de uno o más argumentos, separados por comas.The argument_list consists of one or more argument s, separated by commas.

element_access
    : primary_no_array_creation_expression '[' expression_list ']'
    ;

La argument_list de un element_access no puede contener ref out argumentos o.The argument_list of an element_access is not allowed to contain ref or out arguments.

Un element_access está enlazado dinámicamente (enlace dinámico) si al menos uno de los siguientes contiene:An element_access is dynamically bound (Dynamic binding) if at least one of the following holds:

• El primary_no_array_creation_expression tiene el tipo en tiempo de compilación dynamic .The primary_no_array_creation_expression has compile-time type dynamic.
• Al menos una expresión de la argument_list tiene el tipo en tiempo de compilación dynamic y el primary_no_array_creation_expression no tiene un tipo de matriz.At least one expression of the argument_list has compile-time type dynamic and the primary_no_array_creation_expression does not have an array type.

En este caso, el compilador clasifica el element_access como un valor de tipo dynamic .In this case the compiler classifies the element_access as a value of type dynamic. A continuación, se aplican las siguientes reglas para determinar el significado de la element_access en tiempo de ejecución, utilizando el tipo en tiempo de ejecución en lugar del tipo en tiempo de compilación de las expresiones primary_no_array_creation_expression y argument_list que tienen el tipo en tiempo de compilación dynamic .The rules below to determine the meaning of the element_access are then applied at run-time, using the run-time type instead of the compile-time type of those of the primary_no_array_creation_expression and argument_list expressions which have the compile-time type dynamic. Si el primary_no_array_creation_expression no tiene el tipo en tiempo de compilación dynamic , el acceso al elemento sufre una comprobación de tiempo de compilación limitada, como se describe en comprobación en tiempo de compilación de la resolución de sobrecarga dinámica.If the primary_no_array_creation_expression does not have compile-time type dynamic, then the element access undergoes a limited compile time check as described in Compile-time checking of dynamic overload resolution.

Si el primary_no_array_creation_expression de una element_access es un valor de un array_type, el element_access es un acceso a la matriz (acceso a la matriz).If the primary_no_array_creation_expression of an element_access is a value of an array_type, the element_access is an array access (Array access). De lo contrario, el primary_no_array_creation_expression debe ser una variable o un valor de una clase, estructura o tipo de interfaz que tenga uno o más miembros del indexador, en cuyo caso el element_access es un acceso de indexador (acceso del indexador).Otherwise, the primary_no_array_creation_expression must be a variable or value of a class, struct, or interface type that has one or more indexer members, in which case the element_access is an indexer access (Indexer access).

Acceso a matrizArray access

Para un acceso de matriz, el primary_no_array_creation_expression de la element_access debe ser un valor de un array_type.For an array access, the primary_no_array_creation_expression of the element_access must be a value of an array_type. Además, el argument_list de un acceso de matriz no puede contener argumentos con nombre. El número de expresiones en el argument_list debe ser el mismo que el rango de la array_type, y cada expresión debe ser de tipo int , uint , long , ulong o debe poder convertirse implícitamente a uno o varios de estos tipos.Furthermore, the argument_list of an array access is not allowed to contain named arguments.The number of expressions in the argument_list must be the same as the rank of the array_type, and each expression must be of type int, uint, long, ulong, or must be implicitly convertible to one or more of these types.

El resultado de evaluar un acceso de matriz es una variable del tipo de elemento de la matriz, es decir, el elemento de matriz seleccionado por los valores de las expresiones de la argument_list.The result of evaluating an array access is a variable of the element type of the array, namely the array element selected by the value(s) of the expression(s) in the argument_list.

El procesamiento en tiempo de ejecución de un acceso de matriz del formulario P[A] , donde P es una primary_no_array_creation_expression de un array_type y A es un argument_list, consta de los siguientes pasos:The run-time processing of an array access of the form P[A], where P is a primary_no_array_creation_expression of an array_type and A is an argument_list, consists of the following steps:

• P se evalúa.P is evaluated. Si esta evaluación provoca una excepción, no se ejecuta ningún paso más.If this evaluation causes an exception, no further steps are executed.
• Las expresiones de índice del argument_list se evalúan en orden, de izquierda a derecha.The index expressions of the argument_list are evaluated in order, from left to right. Después de la evaluación de cada expresión de índice, se realiza una conversión implícita (conversiones implícitas) en uno de los siguientes tipos: int , uint , long , ulong .Following evaluation of each index expression, an implicit conversion (Implicit conversions) to one of the following types is performed: int, uint, long, ulong. Se elige el primer tipo de esta lista para el que existe una conversión implícita.The first type in this list for which an implicit conversion exists is chosen. Por ejemplo, si la expresión de índice es de tipo short , se realiza una conversión implícita a int , ya que es posible realizar conversiones implícitas de short a int y de short a long .For instance, if the index expression is of type short then an implicit conversion to int is performed, since implicit conversions from short to int and from short to long are possible. Si la evaluación de una expresión de índice o de la conversión implícita subsiguiente produce una excepción, no se evalúan más expresiones de índice y no se ejecuta ningún paso más.If evaluation of an index expression or the subsequent implicit conversion causes an exception, then no further index expressions are evaluated and no further steps are executed.
• PSe comprueba que el valor de es válido.The value of P is checked to be valid. Si el valor de P es null , System.NullReferenceException se produce una excepción y no se ejecuta ningún paso más.If the value of P is null, a System.NullReferenceException is thrown and no further steps are executed.
• El valor de cada expresión del argument_list se comprueba con respecto a los límites reales de cada dimensión de la instancia de la matriz a la que hace referencia P .The value of each expression in the argument_list is checked against the actual bounds of each dimension of the array instance referenced by P. Si uno o más valores están fuera del intervalo, System.IndexOutOfRangeException se produce una excepción y no se ejecuta ningún paso más.If one or more values are out of range, a System.IndexOutOfRangeException is thrown and no further steps are executed.
• Se calcula la ubicación del elemento de matriz proporcionado por las expresiones de índice y esta ubicación se convierte en el resultado del acceso a la matriz.The location of the array element given by the index expression(s) is computed, and this location becomes the result of the array access.

Acceso a indizadorIndexer access

En el caso de un acceso de indexador, el primary_no_array_creation_expression de la element_access debe ser una variable o valor de un tipo de clase, struct o interfaz, y este tipo debe implementar uno o más indexadores aplicables con respecto a la argument_list del element_access.For an indexer access, the primary_no_array_creation_expression of the element_access must be a variable or value of a class, struct, or interface type, and this type must implement one or more indexers that are applicable with respect to the argument_list of the element_access.

El procesamiento en tiempo de enlace de un acceso del indizador del formulario P[A] , donde P es una primary_no_array_creation_expression de una clase, un struct o un tipo de interfaz T , y A es un argument_list, consta de los siguientes pasos:The binding-time processing of an indexer access of the form P[A], where P is a primary_no_array_creation_expression of a class, struct, or interface type T, and A is an argument_list, consists of the following steps: