Encontre um item na Lista por LINQ?

Aqui eu tenho um exemplo simples para encontrar um item em uma lista de strings. Normalmente eu uso for loop ou delegado anônimo para fazer o seguinte:

int GetItemIndex(string search)
{
   int found = -1;
   if ( _list != null )
   {
     foreach (string item in _list) // _list is an instance of List<string>
     { 
        found++;
        if ( string.Equals(search, item) )
        {
           break;
        }
      }
      /* use anonymous delegate
      string foundItem = _list.Find( delegate(string item) {
         found++;
         return string.Equals(search, item);
      });
      */
   }
   return found;
}

LINQ é novo para mim. Estou curioso para saber se posso usar o LINQ para encontrar itens na lista? Como se possível?

Existem algumas maneiras (observe que essa não é uma lista completa).

1) Single retornará um único resultado, mas lançará uma exceção se encontrar nenhum ou mais de um (que pode ou não ser o que você deseja):

string search = "lookforme";
List<string> myList = new List<string>();
string result = myList.Single(s => s == search);

A nota SingleOrDefault()se comportará da mesma forma, exceto que retornará nulo para tipos de referência ou o valor padrão para tipos de valores, em vez de lançar uma exceção.

2) Onde retornará todos os itens que correspondem aos seus critérios, para que você possa obter um IEnumerable com um elemento:

IEnumerable<string> results = myList.Where(s => s == search);

3) Primeiro retornará o primeiro item que corresponde aos seus critérios:

string result = myList.First(s => s == search);

A nota FirstOrDefault()se comportará da mesma forma, exceto que retornará nulo para tipos de referência ou o valor padrão para tipos de valores, em vez de lançar uma exceção.

Se você deseja o índice do elemento, isso será feito:

int index = list.Select((item, i) => new { Item = item, Index = i })
                .First(x => x.Item == search).Index;

// or
var tagged = list.Select((item, i) => new { Item = item, Index = i });
int index = (from pair in tagged
            where pair.Item == search
            select pair.Index).First();

Você não pode se livrar do lambda no primeiro passe.

Observe que isso será lançado se o item não existir. Isso resolve o problema recorrendo a ints anuláveis:

var tagged = list.Select((item, i) => new { Item = item, Index = (int?)i });
int? index = (from pair in tagged
            where pair.Item == search
            select pair.Index).FirstOrDefault();

Se você deseja o item:

// Throws if not found
var item = list.First(item => item == search);
// or
var item = (from item in list
            where item == search
            select item).First();

// Null if not found
var item = list.FirstOrDefault(item => item == search);
// or
var item = (from item in list
            where item == search
            select item).FirstOrDefault();

Se você deseja contar o número de itens que correspondem:

int count = list.Count(item => item == search);
// or
int count = (from item in list
            where item == search
            select item).Count();

Se você deseja todos os itens que correspondem:

var items = list.Where(item => item == search);
// or
var items = from item in list
            where item == search
            select item;

E não se esqueça de verificar a lista nullem qualquer um desses casos.

Ou use em (list ?? Enumerable.Empty<string>())vez de list.

Obrigado a Pavel por ajudar nos comentários.

Se realmente for um, List<string>você não precisa de LINQ, basta usar:

int GetItemIndex(string search)
{
    return _list == null ? -1 : _list.IndexOf(search);
}

Se você estiver procurando pelo item em si, tente:

string GetItem(string search)
{
    return _list == null ? null : _list.FirstOrDefault(s => s.Equals(search));
}

Deseja o item na lista ou o próprio item real (assumiria o próprio item).

Aqui estão algumas opções para você:

string result = _list.First(s => s == search);

string result = (from s in _list
                 where s == search
                 select s).Single();

string result = _list.Find(search);

int result = _list.IndexOf(search);

Este método é mais fácil e seguro

var lOrders = new List<string>();

bool insertOrderNew = lOrders.Find(r => r == "1234") == null ? true : false

Que tal IndexOf?

Procura o objeto especificado e retorna o índice da primeira ocorrência na lista

Por exemplo

> var boys = new List<string>{"Harry", "Ron", "Neville"};  
> boys.IndexOf("Neville")  
2
> boys[2] == "Neville"
True

Observe que ele retorna -1 se o valor não ocorrer na lista

> boys.IndexOf("Hermione")  
-1

Eu costumava usar um dicionário que é algum tipo de lista indexada que me dá exatamente o que eu quero quando quero.

Dictionary<string, int> margins = new Dictionary<string, int>();
margins.Add("left", 10);
margins.Add("right", 10);
margins.Add("top", 20);
margins.Add("bottom", 30);

Sempre que desejo acessar meus valores de margens, por exemplo, dirijo-me ao meu dicionário:

int xStartPos = margins["left"];
int xLimitPos = margins["right"];
int yStartPos = margins["top"];
int yLimitPos = margins["bottom"];

Portanto, dependendo do que você está fazendo, um dicionário pode ser útil.

Aqui está uma maneira de reescrever seu método para usar o LINQ:

public static int GetItemIndex(string search)
{
    List<string> _list = new List<string>() { "one", "two", "three" };

    var result = _list.Select((Value, Index) => new { Value, Index })
            .SingleOrDefault(l => l.Value == search);

    return result == null ? -1 : result.Index;
}

Assim, chamando-o com

GetItemIndex("two") retornará 1 ,

e

GetItemIndex("notthere") retornará -1 .

Referência: linqsamples.com

Tente este código:

return context.EntitytableName.AsEnumerable().Find(p => p.LoginID.Equals(loginID) && p.Password.Equals(password)).Select(p => new ModelTableName{ FirstName = p.FirstName, UserID = p.UserID });

Se precisarmos encontrar um elemento da lista, podemos usar o método Finde FindAllextensions, mas há uma pequena diferença entre eles. Aqui está um exemplo.

 List<int> items = new List<int>() { 10, 9, 8, 4, 8, 7, 8 };

  // It will return only one 8 as Find returns only the first occurrence of matched elements.
     var result = items.Find(ls => ls == 8);      
 // this will returns three {8,8,8} as FindAll returns all the matched elements.
      var result1 = items.FindAll(ls => ls == 8); 

Isso o ajudará a obter o primeiro valor ou o valor padrão em sua pesquisa na lista Linq

var results = _List.Where(item => item == search).FirstOrDefault();

Esta pesquisa encontrará o primeiro valor ou valor padrão que ele retornará.

Você deseja pesquisar um objeto na lista de objetos.

Isso ajudará você a obter o primeiro valor ou o valor padrão na sua pesquisa da lista Linq.

var item = list.FirstOrDefault(items =>  items.Reference == ent.BackToBackExternalReferenceId);

ou

var item = (from items in list
    where items.Reference == ent.BackToBackExternalReferenceId
    select items).FirstOrDefault();

Você pode usar FirstOfDefault com a extensão Where Linq para obter uma classe MessageAction do IEnumerable. Reme

var action = Message.Actions.Where (e => e.targetByName == className) .FirstOrDefault ();

Onde

Listar ações {get; conjunto; }