.net - procedimientos - parametros opcionales c#

¿Cómo funcionan los parámetros opcionales de VB.NET ''Under the hood''? ¿Son CLS-obedientes?

Question

Digamos que tenemos la siguiente declaración de método:

Public Function MyMethod(ByVal param1 As Integer, _
    Optional ByVal param2 As Integer = 0, _
    Optional ByVal param3 As Integer = 1) As Integer

    Return param1 + param2 + param3
End Function

¿Cómo hace VB.NET para que los parámetros opcionales funcionen dentro de los límites del CLR? ¿Son los parámetros opcionales CLS-obedientes?

Answer 1

Contrario a la creencia popular, los parámetros opcionales parecen ser CLS-obedientes. (Sin embargo, mi principal comprobación para esto fue marcar el ensamblaje, la clase y el método, todo con el atributo CLSCompliant, establecido en True).

Entonces, ¿qué aspecto tiene esto en MSIL?

.method public static int32  MyMethod(int32 param1,
                                      [opt] int32 param2,
                                      [opt] int32 param3) cil managed
{
  .custom instance void [mscorlib]System.CLSCompliantAttribute::.ctor(bool) = ( 01 00 01 00 00 ) 
  .param [2] = int32(0x00000000)
  .param [3] = int32(0x00000001)
  // Code size       11 (0xb)
  .maxstack  2
  .locals init ([0] int32 MyMethod)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  ldarg.1
  IL_0003:  add.ovf
  IL_0004:  ldarg.2
  IL_0005:  add.ovf
  IL_0006:  stloc.0
  IL_0007:  br.s       IL_0009
  IL_0009:  ldloc.0
  IL_000a:  ret
} // end of method Module1::MyMethod

Tenga en cuenta las marcas [opt] en los parámetros: MSIL admite esto de forma nativa, sin ningún tipo de intrusión. (A diferencia del soporte de MSIL para la palabra clave estática de VB, que es otro tema en total).

Entonces, ¿por qué no están estos en C #? No puedo responder a eso, aparte de mi especulación de que podría ser una presunta falta de demanda. Mi preferencia siempre ha sido especificar los parámetros, incluso si fueran opcionales: para mí, el código se ve más limpio y es más fácil de leer. (Si hay parámetros omitidos, a menudo busco primero una sobrecarga que coincida con la firma visible; solo después de que no encuentro una, me doy cuenta de que están involucrados parámetros opcionales).

Answer 2

Curiosamente, este es el código descompuesto de C #, obtenido a través del reflector.

public int MyMethod(int param1, 
                   [Optional, DefaultParameterValue(0)] int param2, 
                   [Optional, DefaultParameterValue(1)] int param3)
{
    return ((param1 + param2) + param3);
}

Observe los atributos Opcional y DefaultParameterValue. Intenta ponerlos en métodos C #. Descubrirá que todavía está obligado a pasar valores al método. ¡Sin embargo, en el código VB, se convirtió en Default! Dicho esto, personalmente nunca he usado el valor predeterminado incluso en el código VB. Se siente como un truco. La sobrecarga de métodos me funciona.

Sin embargo, el hecho de predeterminar ayuda al tratar con la interoperabilidad de Excel, que es un dolor en el culo para usar directamente de la caja en C #.