c# - operadores - ¿Es esta gran cosa complicada igual a esto? ¿o esto? ¿o esto?

operadores logicos c# ejemplos

Question

Digamos que estoy trabajando con un objeto de clase. La forma en que estoy recibiendo este objeto es un poco prolijo:

 BigObjectThing.Uncle.PreferredInputStream.NthRelative(5)

Me gustaría ver si esta thing es igual a x o y o z . La forma ingenua de escribir esto podría ser:

 BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) == x ||
BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) == y ||
BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) == z

En algunos idiomas podría escribir algo como esto:

 BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) == x |= y |= z

pero C # no permite eso.

¿Existe una forma idiomática de C # para escribir esta prueba como una sola expresión ?

Answer 1

¿Tales cosas en una expresión ? Esto requiere mi habilidad LINZ loca !

Muestra de trabajo ( http://ideone.com/VNTFnz ):

using System.Linq;
public class Test
{
static int getStuff()
{
return 1;
}
public static void Main()
{
if ((from option in new int[] {1, 2, 3}
let thing = getStuff()
where option == thing
select option).Any())
System.Console.WriteLine("in the list!");
}
}

Traducido para su caso, sería algo como esto:

 if ((from option in new Thing[] {x, y, z}
let thing = BigObjectThing.Uncle.PreferredInputStream.NthRelative(5)
where option == thing
select option).Any())
System.Console.WriteLine("in the list!");

No estoy diciendo que debas hacerlo de esta manera, pero bueno, obtienes el resultado booleano, puedes verificar cualquier número de valores en lugar de x , y , y z ! Además, esto no te limita a la comparación con == , puedes usar lo que quieras en su lugar.

Y oye, una expresión !

Bromas aparte, pensar en formas extrañas de hacer lo que quería hacer es divertido, ¡pero realmente debería poner el resultado de BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) en una variable!

Answer 2

Como otros han señalado, una colección es una forma en que puedes hacer esto. Si quisiera tener un poco más de flexibilidad que usar Contains (que solo le permite probar x.Equals(y) ), e incluso admite el encadenamiento con &= además de |= , sugeriría los métodos de extensión Any o All incorporado en .NET.

var compares = new[] { x, y, z };
var relative = BigObjectThing.Uncle.PreferredInputStream.NthRelative(5);
// Simulate |= behavior
return compares.Any(x => relative == x);
// Simulate &= behavior
return compares.All(x => relative == x);
// A more complex test chained by OR
return compares.Any(x => relative.SomeProperty == x.SomeProperty);
// A less readable but one-line approach
return (new [] {x, y, x}).Any(x => BigObjectThing.Uncle.PreferredInputStream.NthRelative(5) == x);

Answer 3

Solo usa una variable:

var relative = BigObjectThing.Uncle.PreferredInputStream.NthRelative(5);
return relative == x || relative == y || relative == z;

O si quieres ser elegante con un conjunto más amplio de cosas:

var relatives = new HashSet<thing>(new[] { x, y, z });
return relatives.Contains(BigObjectThing.Uncle.PreferredInputStream.NthRelative(5));

Answer 4

Un método de extensión simularía esto:

public static bool EqualsAny(this Thing thing, params object[] compare)
{
return compare.Contains(thing);
}
bool result = BigObjectThing.Uncle.PreferredInputStream.NthRelative(5).EqualsAny(x, y, z);

C # no tiene una sintaxis predeterminada para una comparación semejante al OR como afaik.

Answer 5

Usted podría poner sus objetos en una Collection primero y luego usar Contains() .

 var relatives = new Collection<Thing> { x, y, z };
if (relatives.Contains(BigObjectThing.Uncle.PreferredInputStream.NthRelative(5)))
{
...
}

Esto podría reducirse aún más (en aras de la legibilidad):

if (new Collection<Thing> { x, y, z }.Contains(BigObjectThing.Uncle.PreferredInputStream.NthRelative(5)))
{
...
}