Simplificar si (x == 1 || x == 2)

Question

Duplicar posibles:
C# if statements matching multiple values

a menudo me encuentro escribiendo código en la que una variable puede ser A o B , por ejemplo cuando llamo OnItemDataBound en un repetidor:

protected void repeater_OnItemDataBound(object sender, RepeaterItemEventArgs e) 
{ 
    if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem) 
    {} 
} 

entonces menudo pienso, tiene que haber una manera más sencilla de hacer esto. Me gustaría escribir algo como:

if(x == (1 || 2)) 

SQL tiene el operador IN (..), ¿hay algo similar en C#?

WHERE x IN(1,2) 

Sé que podría usar una declaración de cambio en su lugar, pero eso no es lo suficientemente simple. Quiero que se haga en una declaración If, si es posible.

Answer 1

Si desea imitar la sentencia SQL IN, podría hacer algo como esto ... para el caso simple de tener 2 elementos, esto probablemente no sea más simple, pero para más elementos, ciertamente lo sería.

(new[] { 1, 2 }).Contains(x); 

Answer 2

Creo que está bien como está; Sin embargo, usted podría hacer algo como:

// note the array is actually mutable... just... don't change the contents ;p 
static readonly ListItemType[] specialTypes = 
    new[]{ListItemType.Item, ListItemType.AlternatingItem}; 

y comprobar en contra:

if(specialTypes.Contains(e.Item.ItemType)) { 
    // do stuff 
} 

Pero destacar: Me realidad sólo tiene que utilizar un switch aquí, como switch en números enteros y enumeraciones tiene un manejo especial IL a través de salto-mesas, por lo que es muy eficiente:

switch(e.Item.ItemType) { 
    case ListItemType.Item: 
    case ListItemType.AlternatingItem: 
     // do stuff 
     break; 
} 

Answer 3

menos que no haya demasiado tanto las posibles opciones f o solo if, su código es legible y claro, que es lo más importante.

Si menudo se encuentran con más if la condición 3, puede utilizar

new List<..>{ condition1, condition2, ... ConditionN}.Any<>().

Algo así.

Answer 4

Se puede escribir un método de extensión de esta manera:

public static bool In<T>(this T x, params T[] values) 
{ 
    return values.Contains(x); 
} 

y lo llaman así:

1.In(2,3,4) 

pero yo diría que no vale la pena el esfuerzo.

Answer 5

Usted puede utilizar el siguiente método, que se encuentra en this Answer

public static bool In<T>(this T source, params T[] list) 
{ 
    if(null==source) throw new ArgumentNullException("source"); 
    return list.Contains(source); 
} 

llamada así:

if(x.In(1,2,4)) 
{ 
     // ... 
} 

Answer 6

Creo que es tan simple como que se va a conseguir. Observe cómo las otras respuestas o incluso su propia sugerencia realmente usan constructos especiales y soluciones para acortar un poco de sintaxis trivial. Además, estas ingeniosas soluciones evitarán el rendimiento.

Pero, para dos o tres elementos que ocupan mucho espacio, me gusta poner las condiciones en las líneas siguientes para facilitar la lectura.

if (x == MyEnum.SomeReallyLongNameThatEatsUpTheLine || 
    x == MyEnum.TheOtherNameThatWastesSpace) 
{ 
// The simplest code. 
} 

Supongo que si tuviera una lista muy larga de valores posibles, el enfoque de matriz es mucho mejor.