C#7: subrayado(_) y estrella(*) en la variable de salida

c#-7.0

Question

Estaba leyendo sobre nuevas características variables en C # 7 here . Tengo dos preguntas:

1. Dice

   También permitimos los "descartes" como parámetros de salida, en forma de _ , para que pueda ignorar los parámetros que no le interesan:

   p.GetCoordinates(out var x, out _); // I only care about x

   P: Supongo que esto es solo una información y no una nueva característica de C # 7 porque también podemos hacerlo en pre C # 7.0:

   var _;
   if (Int.TryParse(str, out _))
   ...

   o me estoy perdiendo algo aquí?

2. Mi código da un error cuando hago lo mencionado en el mismo blog:

   ~Person() => names.TryRemove(id, out *);

   * no es un identificador válido. ¿Un descuido de Mads Torgersen, supongo?

Answer 1

Para los más curiosos

Considere el siguiente fragmento

static void Main(string[] args)
{
//....
int a;
int b;
Test(out a, out b);
Test(out _, out _);
//....
}
private static void Test(out int a, out int b)
{
//...
}

Esto es lo que está pasando:

...
13: int a;
14: int b;
15:
16: Test(out a, out b);
02340473 lea ecx,[ebp-40h]
02340476 lea edx,[ebp-44h]
02340479 call 02340040
0234047E nop
17: Test(out _, out _);
0234047F lea ecx,[ebp-48h]
02340482 lea edx,[ebp-4Ch]
02340485 call 02340040
0234048A nop
...

Como puede ver detrás de escena, las dos llamadas están haciendo lo mismo.

Como señaló @ Servé Laurijssen, lo bueno es que no tiene que declarar previamente las variables, lo cual es útil si no está interesado en algunos valores.

Answer 2

Otro ejemplo del Operador de descarte _ en C # 7 es hacer coincidir un patrón con una variable de tipo object en una instrucción switch , que se agregó recientemente en C # 7:

Código:

static void Main(string[] args)
{
object x = 6.4;
switch (x)
{
case string _:
Console.WriteLine("it is string");
break;
case double _:
Console.WriteLine("it is double");
break;
case int _:
Console.WriteLine("it is int");
break;
default:
Console.WriteLine("it is Unknown type");
break;
}
// end of main method
}

Este código coincidirá con el tipo y descartará la variable pasada al case ... _ .

Answer 3

Sobre la primera pregunta

Supongo que esto es solo una información y no una nueva característica de C # 7 porque también podemos hacerlo en pre C # 7.0.

var _;
if (Int.TryParse(str, out _))
// ...

La novedad es que ya no tiene que declarar _ dentro o fuera de la expresión y simplemente puede escribir

int.TryParse(s, out _);

Intenta hacer este liner pre C # 7:

private void btnDialogOk_Click_1(object sender, RoutedEventArgs e)
{
DialogResult = int.TryParse(Answer, out _);
}

Answer 4

Discards , en C # 7, se pueden usar siempre que se declare una variable para, como su nombre indica, descartar el resultado. Por lo tanto, se puede usar un descarte sin variables:

p.GetCoordinates(out var x, out _);

y se puede usar para descartar un resultado de expresión:

_ = 42;

En el ejemplo,

p.GetCoordinates(out var x, out _);
_ = 42;

No se introduce ninguna variable _ . Solo se utilizan dos casos de descarte.

Sin embargo, si existe un identificador _ en el ámbito, no se pueden usar los descartes:

var _ = 42;
_ = "hello"; // error - a string cannot explicitly convert from string to int

La excepción a esto es cuando se usa una variable _ como variable de salida. En este caso, el compilador ignora el tipo o var y lo trata como un descarte:

if (p.GetCoordinates(out double x, out double _))
{
_ = "hello"; // works fine.
Console.WriteLine(_); // error: _ doesn''t exist in this context.
}

Tenga en cuenta que esto solo ocurre si, en este caso, se usa out var _ o out double _ . Simplemente use out _ y luego se trata como una referencia a una variable existente, _ , si está dentro del alcance, por ejemplo:

string _;
int.TryParse("1", out _); // complains _ is of the wrong type

Finalmente, la notación * se propuso al principio de las discusiones sobre descartes, pero se abandonó a favor de _ debido a que esta última es una notación más utilizada en otros idiomas .