Listenin bir dize içeren öğe içerip içermediğini kontrol edin ve bu öğeyi alın

Bu soruya bir cevap ararken, LINQ kullanarak benzer sorulara rastladım, ancak onları tam olarak anlayamadım (ve böylece uygulayamadım), çünkü aşina olmadığım için. Temel olarak, istediğim şudur:

1. Listedeki herhangi bir öğenin belirli bir dize içerip içermediğini kontrol edin.
2. Varsa, o öğeyi alın.

Dürüst olmak gerekirse, bunu nasıl yapacağımı bilmiyorum. Ne gelebilir bu (elbette çalışmıyor):

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

NEDEN işe yaramadığını biliyorum:

• myList.Contains()Döndürmez true, çünkü listenin tüm bir öğesinin belirttiğim dizeyle eşleşip eşleşmediğini kontrol eder.
• myList.IndexOf() bir olay bulamaz, çünkü yine olduğu gibi, dizeyle eşleşen bir öğeyi kontrol eder.

Yine de, bu sorunun nasıl çözüleceğine dair hiçbir fikrim yok, ama benimkine benzer sorularda önerildiği gibi LINQ kullanmak zorunda kalacağımı düşünüyorum. Bununla birlikte, burada durum buysa, cevaplayıcının bana örneklerinde LINQ kullanımını açıklamasını istiyorum (dediğim gibi, C # ile zamanımda bununla uğraşmadım). Şimdiden teşekkürler çocuklar (ve kızlar?).

EDIT: Bir çözüm buldum; sadece listede dolaşın, geçerli öğenin dizeyi içerip içermediğini kontrol edin ve sonra geçerli öğeye eşit bir dize ayarlayın. Merak ediyorum, bundan daha etkili bir yol var mı?

string myString = "bla";
string element = "";

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

Linq'i burada kullanabilmelisiniz:

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

İlk eşleşen öğeyi iade etmek istiyorsanız:

var match = myList
    .FirstOrDefault(stringToCheck => stringToCheck.Contains(myString));

if(match != null)
    //Do stuff

Temel cevap şudur: döngü boyunca yineleme yapmanız ve belirtilen dizeyi içeren herhangi bir öğeyi kontrol etmeniz gerekir. Diyelim ki kod:

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

Eşdeğer, ancak kısa kod:

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

Burada x, yukarıdaki kodda "item" gibi davranan bir parametredir.

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

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;
    }
}

Eski moda döngüleri neredeyse her zaman en hızlısıdır.

Dizenizi içeren dizelerin bir listesini istiyorsanız:

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

Başka bir seçenek Linq FirstOrDefault kullanmaktır

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

ContainsYöntemin büyük / küçük harfe duyarlı olduğunu unutmayın .

Linq'in FirstOrDefaultuzantı yöntemini kullanabilirsiniz :

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

Bu, alt dizeyi içeren yumruk öğesini myStringveya nullböyle bir öğe bulunmazsa döndürülür .

İhtiyacınız olan tek şey dizinse, List<T>sınıfın FindIndexyöntemini kullanın :

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

Bu, alt dizeyi içeren yumruk öğesinin dizinini myStringveya -1böyle bir öğe bulunmazsa döndürülür .

Burada çok iyi cevaplar var, ancak aşağıdaki gibi Var olanları kullanarak basit bir cevap kullanıyorum :

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);
}

Böyle bir şey kullanabilmelisin, benim için iyi çalıştı:

var valuesToMatch = yourList.Where(stringCheck => stringCheck.Contains(myString));

ya da bunun gibi bir şey, eğer eşleşmediği yere bakmanız gerekiyorsa.

 var valuesToMatch = yourList.Where(stringCheck => !stringCheck.Contains(myString));

kullanabilirsiniz

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

LINQ, herhangi bir veri koleksiyonunu "sorgulamak" için olanak sağlar. Bir koleksiyonda (burada dizelerin koleksiyonu (liste)) bir veritabanı sorgusu (select, where, vb.) Gibi sözdizimini kullanabilirsiniz.

bu yüzden "beni listeden ürün al"

"lambda ifadesi" kullandığınız yer içinde

kısaca lambda ifadesinin şöyle bir şey olduğunu söylemek için (input parametresi => return değeri)

yani "item" parametresi için "item.Contains (" zorunlu dize ")" döndürür. Bu nedenle, öğe dizeyi içeriyorsa true değerini döndürür ve bu nedenle, koşulu karşıladığından beri listeden seçilir.

Basit tutmak için bunu kullanın;

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.
 }
}

Alternatif olarak, bunu for döngüsü ile yapmak için şunu kullanın;

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

Kod aşağıda birisine yardımcı olacağını umuyoruz diğer cevaplarda bool seçeneği görmedim.

Sadece kullan Any()

string myString = "test";
bool exists = myList
             .Where(w => w.COLUMN_TO_CHECK.Contains(myString)).Any();

Herhangi, Nerede, İlk ve İlk Veya Varsayılan'ı birleştirmek mümkündür; ya da gerekli olana bağlı olarak yüklemi bu yöntemlerden herhangi birine yerleştirebilirsiniz.

Herhangi bir eşleşme bulunmadığında bir istisna atılmak istemiyorsanız, muhtemelen First kullanmaktan kaçınmalısınız. FirstOrDefault, eşleşme bulunmazsa türün varsayılanını döndüreceğini bildiğiniz sürece genellikle daha iyi bir seçenektir (dizenin varsayılan değeri null, int 0, bool false, vb.).

using System.Collections.Generic;
using System.Linq;


bool exists;
string firstMatch;
IEnumerable<string> matchingList;

var myList = new List<string>() { "foo", "bar", "foobar" };

exists = myList.Any(x => x.Contains("o"));
// exists => true

firstMatch = myList.FirstOrDefault(x => x.Contains("o"));
firstMatch = myList.First(x => x.Contains("o"));
// firstMatch => "foo"

firstMatch = myList.First(x => x.Contains("dark side"));
// throws exception because no element contains "dark side"

firstMatch = myList.FirstOrDefault(x => x.Contains("dark side"));
// firstMatch => null

matchingList = myList.Where(x => x.Contains("o")); 
// matchingList => { "foo", "foobar" }

Bu kodu test edin @ https://rextester.com/TXDL57489