ultimo - obtener elemento de una lista c#

Compruebe si la lista contiene un elemento que contiene una cadena y obtiene ese elemento

Question

Al buscar una respuesta a esta pregunta, me he encontrado con otros similares que utilizan LINQ pero no he podido comprenderlos completamente (y por lo tanto, implementarlos), ya que no estoy familiarizado con esto. Lo que me gustaría, básicamente, es esto:

1. Compruebe si algún elemento de una lista contiene una cadena específica.
2. Si lo hace, obtén ese elemento.

Honestamente, no sé cómo voy a hacer eso. Lo que puedo pensar es esto (no funciona, por supuesto):

if (myList.Contains(myString))
string element = myList.ElementAt(myList.IndexOf(myString));

Sé POR QUÉ no funciona:

• myList.Contains() no devuelve true , ya que comprobará si un elemento completo de la lista coincide con la cadena especificada.
• myList.IndexOf() no encontrará una ocurrencia, ya que, como es el caso de nuevo, buscará un elemento que coincida con la cadena.

Aún así, no tengo ni idea de cómo resolver este problema, pero creo que tendré que usar LINQ como se sugiere en las preguntas similares a las mías. Dicho esto, si ese es el caso aquí, me gustaría que el que responde me explique el uso de LINQ en su ejemplo (como dije, no me molesté en mi tiempo con C #). Gracias de antemano chicos (¿y chicas?).

EDITAR: He encontrado una solución; simplemente recorra la lista, verifique si el elemento actual contiene la cadena y luego establezca una cadena igual al elemento actual. Me pregunto, sin embargo, ¿hay una manera más eficiente que esto?

string myString = "bla";
string element = "";
for (int i = 0; i < myList.Count; i++)
{
if (myList[i].Contains(myString))
element = myList[i];
}

Answer 1

Deberías poder usar Linq aquí:

var matchingvalues = myList
.Where(stringToCheck => stringToCheck.Contains(myString));

Si simplemente desea devolver el primer elemento correspondiente:

var match = myList
.FirstOrDefault(stringToCheck => stringToCheck.Contains(myString));
if(match != null)
//Do stuff

Answer 2

La respuesta básica es que necesita iterar a través del ciclo y verificar que cualquier elemento contenga la cadena especificada. Entonces, digamos que el código es

foreach(string item in myList)
{
if(item.Contains(myString))
return item;
}

El código equivalente pero concisa es

mylist.Where(x => x.Contains(myString)).FirstOrDefault();

Aquí, x es un parámetro que actúa como elemento en el código anterior.

Answer 3

Para mantenerlo simple, usa esto;

foreach(string item in myList)//Iterate through each item.
{
if(item.Contains("Search Term")//True if the item contains search pattern.
{
return item;//Return the matched item.
}
}

Alternativamente, para hacer esto con for loop, use esto;

 for (int iterator = 0; iterator < myList.Count; iterator++)
{
if (myList[iterator].Contains("String Pattern"))
{
return myList[iterator];
}
}

Answer 4

Puede usar el método de extensión FirstOrDefault de Linq:

string element = myList.FirstOrDefault(s => s.Contains(myString));

Esto devolverá el primer elemento que contiene la subcadena myString , o null si no se encuentra dicho elemento.

Si todo lo que necesita es el índice, use el método FindIndex la clase List<T> :

int index = myList.FindIndex(s => s.Contains(myString));

Esto devolverá el índice del primer elemento que contiene la subcadena myString , o -1 si no se encuentra dicho elemento.

Answer 5

Si desea una lista de cadenas que contienen su cadena:

var newList = myList.Where(x => x.Contains(myString)).ToList();

Otra opción es usar Linq FirstOrDefault

var element = myList.Where(x => x.Contains(myString)).FirstOrDefault();

Tenga en cuenta que el método Contains distingue entre mayúsculas y minúsculas.

Answer 6

muchas buenas respuestas aquí, pero utilizo una simple como la siguiente, usando Exists

foreach (var setting in FullList)
{
if(cleanList.Exists(x => x.ProcedureName == setting.ProcedureName))
setting.IsActive = true; // do you business logic here
else
setting.IsActive = false;
updateList.Add(setting);
}

Answer 7

puedes usar

var match=myList.Where(item=>item.Contains("Required String"));
foreach(var i in match)
{
//do something with the matched items
}

LINQ le proporciona capacidades para "consultar" cualquier colección de datos. Puede usar la sintaxis como una consulta de base de datos (seleccionar, dónde, etc.) en una colección (aquí la colección (lista) de cadenas).

por lo que está haciendo como "obtener elementos de la lista donde satisface una condición dada"

dentro de Donde estás usando una "expresión lambda"

decir brevemente la expresión lambda es algo así como (parámetro de entrada => valor de retorno)

entonces para un parámetro "artículo", devuelve "item.Contains (" required string ")". Por lo tanto, devuelve verdadero si el elemento contiene la cadena y, por lo tanto, se selecciona de la lista, ya que cumple la condición.

Answer 8

for (int i = 0; i < myList.Length; i++)
{
if (myList[i].Contains(myString)) // (you use the word "contains". either equals or indexof might be appropriate)
{
return i;
}
}

Los viejos bucles de moda casi siempre son los más rápidos.

Answer 9

string result = myList.FirstOrDefault(x => x == myString)
if(result != null)
{
//found
}