c# - programacion - operadores logicos en c

¿Hay un operador C#IN?

Question

En SQL, puede usar la siguiente sintaxis:

SELECT *
FROM MY_TABLE
WHERE VALUE_1 IN (1, 2, 3)

¿Hay un equivalente en C #? El IDE parece reconocer "en" como palabra clave, pero parece que no puedo encontrar información sobre él.

Entonces, ¿es posible hacer algo como lo siguiente?

int myValue = 1;
if (myValue in (1, 2, 3))
// Do something

En lugar de

int myValue = 1;
if (myValue == 1 || myValue == 2 || myValue == 3)
// Do something

Answer 1

Acepto que la mejor manera de implementar el operador In es con un Método de extensión. Lo hice un poco diferente:

public static bool In(this string str, string CommaDelimintedStringSet)
{
string[] Values = CommaDelimintedStringSet.Split(new char[] { '','' });
foreach (string V in Values)
{
if (str == V)
return true;
}
return false;
}

La diferencia es que no tiene que poner comillas alrededor de cada valor, solo el conjunto completo de valores delimitados por comas, que es más fácil de escribir:

bool result = MyString.In("Val1,Val2,Val3");

Answer 2

Duplicado de: LINQ to SQL in y no en

select * from table where fieldname in (''val1'', ''val2'')

o

select * from table where fieldname not in (1, 2)

El equivalente de las consultas IN y NOT IN en LINQ to SQL sería algo como esto:

List<string> validValues = new List<string>() { "val1", "val2"};
var qry = from item in dataContext.TableName
where validValues.Contains(item.FieldName)
select item;

y esto:

List<int> validValues = new List<int>() { 1, 2};
var qry = from item in dataContext.TableName
where !validValues.Contains(item.FieldName)
select item;

Answer 3

La palabra clave in en C # es para la instrucción foreach y para las expresiones de consulta LINQ. No existe una funcionalidad equivalente al operador de SQL en C # per se, pero LINQ ofrece una funcionalidad similar con Contains() .

var list = {1, 2, 3}
var filtered = (
from item in items
where list.Contains(item)
select item).ToArray().

Answer 4

No hay ningún operador que busque un valor en una colección, sino que es un método de la colección, llamado Contains .

La solución más escalable es usar un HashSet como colección. La comprobación de un valor en un HashSet está cerca de una operación O (1), en comparación con hacerlo en una List donde se trata de una operación O (n). Eso significa que puede empaquetar una gran cantidad de valores en un HashSet y aún así es rápido, mientras que buscar un valor en una List vuelve más lento HashSet más valores tenga.

Ejemplo:

var set = new HashSet<int>();
set.Add(1);
set.Add(2);
set.Add(3);
var result = items.Select(i => set.Contains(i.value));

Answer 5

No hay un operador "in" en C #, la palabra clave "in" se usa solo con "foreach (... in ...)" o "from ... in ...".

El equivalente LINQ de su consulta SQL sería:

List<int> list = new List<int> { 1, 2, 3 };
var query = from row in my_table
where list.Contains(row.value1)
select row;

Answer 6

Para dígitos del 0 al 9:

"123".Contains(myValue)

Para cualquier otra cosa:

"|1|2|3|".Contains("|" + myValue + "|")

Answer 7

Para ti pregunta actualizada

hacer uso del interruptor

switch (myvalue)
{
case 1:
case 2:
case 3:
// your code gose here
break;
}

Answer 8

Puedes escribir una extensión Escribí hace un tiempo, por hacer código como

if(someObject.stringPropertyX.Equals("abc") || someObject.stringPropertyX.Equals("def") || ....){
//do something
...
}else{
//do something other...
....
}

más legible con una extensión st uno fue capaz de escribir

if(someObject.stringPropertyX.In("abc", "def",...,"xyz"){
//do something
...
}else{
//do something other...
....
}

Aquí está el code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Some.Namespace.Extenders
{
public static class StringExtender
{
/// <summary>
/// Evaluates whether the String is contained in AT LEAST one of the passed values (i.e. similar to the "in" SQL clause)
/// </summary>
/// <param name="thisString"></param>
/// <param name="values">list of strings used for comparison</param>
/// <returns><c>true</c> if the string is contained in AT LEAST one of the passed values</returns>
public static bool In(this String thisString, params string[] values)
{
foreach (string val in values)
{
if (thisString.Equals(val, StringComparison.InvariantCultureIgnoreCase))
return true;
}
return false; //no occurence found
}
}
}

Este es el específico para mis necesidades en ese momento, pero puede adaptarlo y modificarlo para que coincida con más tipos diferentes.

Answer 9

Puedes hacerlo:

var x = 99; // searched value
if (new[] {1,2,3,99}.Contains(x))
{
// do something
}

Answer 10

Si quisiera escribir .En entonces podría crear una extensión que le permita hacer eso.

static class Extensions
{
public static bool In<T>(this T item, params T[] items)
{
if (items == null)
throw new ArgumentNullException("items");
return items.Contains(item);
}
}
class Program
{
static void Main()
{
int myValue = 1;
if (myValue.In(1, 2, 3))
// Do Somthing...
string ds = "Bob";
if (ds.In("andy", "joel", "matt"))
// Do Someting...
}
}

Answer 11

Usualmente usas el método Contains de una colección.

myCollection.Where(p => Enumerable.Range(1,3).Contains(p));

Espero que ayude.

Answer 12

List.Contains() es lo que estás buscando. C # tiene una keyword y no un operator que tiene un propósito completamente diferente a lo que se refiere en SQL.

Hay dos maneras en que puede usar la palabra clave en C #. Supongamos que tiene una cadena [] o una lista en C #.

 string[] names; //assume there are some names;
//find all names that start with "a"
var results = from str in names
where str.StartsWith("a")
select str;
//iterate through all names in results and print
foreach (string name in results)
{
Console.WriteLine(name);
}

En referencia a su edición, pondría su código de esta manera para hacer lo que necesita.

 int myValue = 1;
List<int> checkValues = new List<int> { 1, 2, 3 };
if (checkValues.Contains(myValue))
// Do something