जांचें कि क्या सूची में वह तत्व है जिसमें एक स्ट्रिंग शामिल है और उस तत्व को प्राप्त करें

Question

इस प्रश्न के उत्तर की खोज करते हुए, मैं LINQ का उपयोग करने वाले समान लोगों में चला गया हूं, लेकिन मैं उन्हें पूरी तरह से समझने में सक्षम नहीं हूं (और इस प्रकार, उन्हें लागू करता हूं), क्योंकि मैं इससे परिचित नहीं हूं। मूल रूप से, मैं यह करना चाहूंगा:

1. जांचें कि किसी सूची के किसी तत्व में कोई विशिष्ट स्ट्रिंग है या नहीं।
2. यदि ऐसा होता है, तो उस तत्व को प्राप्त करें।

मैं ईमानदारी से नहीं जानता कि मैं ऐसा कैसे करूंगा। मैं इसके साथ आ सकता हूं (काम नहीं कर रहा है, निश्चित रूप से):

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

मुझे पता है कि यह क्यों काम नहीं करता है:

• myList.Contains()वापस नहीं आता है true, क्योंकि यह जाँच करेगा कि सूची का एक पूरा तत्व मेरे द्वारा निर्दिष्ट स्ट्रिंग से मेल खाता है या नहीं।
• myList.IndexOf() एक घटना नहीं मिलेगी, चूंकि यह मामला फिर से है, यह स्ट्रिंग से मेल खाने वाले तत्व की जांच करेगा।

फिर भी, मेरे पास इस समस्या को हल करने के लिए कोई सुराग नहीं है, लेकिन मुझे लगता है कि मुझे मेरे जैसे ही प्रश्नों में सुझाए गए LINQ का उपयोग करना होगा। कहा जा रहा है, अगर ऐसा है तो यहाँ, मैं उत्तर देने वाले के लिए चाहूँगा कि मैं उनके उदाहरण में LINQ के उपयोग की व्याख्या करूँ (जैसा कि मैंने कहा, मैंने अपने समय में C # के साथ इसे परेशान नहीं किया है)। अग्रिम लोगों (और लड़कियों?) में धन्यवाद।

संपादित करें: मैं एक समाधान के साथ आया हूं; सूची के माध्यम से बस लूप करें, जांचें कि क्या वर्तमान तत्व में स्ट्रिंग है और फिर वर्तमान तत्व के बराबर स्ट्रिंग सेट करें। मैं सोच रहा हूं, हालांकि, क्या इससे अधिक कुशल तरीका है?

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

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

Comments

जैसा कि मैंने अपने उत्तर में उल्लेख किया है, पुराने फैशन लूप (जैसे आपके पास आपका प्रश्न है) लगभग हमेशा सबसे तेज होते हैं। लेकिन अगर आप पर्याप्त देखभाल करते हैं तो आप इसका परीक्षण कर सकते हैं।

— मैके

आपकी सूची में कई तार हो सकते हैं myString, जिसमें आपका तार , आपके वर्तमान लूप में, आपको अंतिम तत्व मिलेगा। यह आप पर निर्भर करता है कि क्या आप पहले या आखिरी को ढूंढना चाहते हैं, अगर आप सिर्फ पहला खोजना चाहते हैं, तो आइटम खोजने के बाद लूप को तोड़ दें।

— हबीब

Answer 1

आप यहाँ Linq का उपयोग करने में सक्षम होना चाहिए:

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

यदि आप पहली मिलान वस्तु वापस करना चाहते हैं:

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

if(match != null)
    //Do stuff

Comments

+1 - या बदलने के Whereसाथ FirstOrDefaultअपने दूसरे मामले मेंmyList.FirstOrDefault(stringToCheck => stringToCheck.Contains(myString))

— हबीब

बहुत बढ़िया जवाब। बस जिज्ञासा से बाहर, यद्यपि: ऐसा क्यों है कि matchingसंकलक-निर्धारित ( var) है? चूंकि मुझे पता है कि मेरी सूची प्रकार की है String, तो क्या string matchingइस मामले में उपयोग करना सुरक्षित होगा ?

— दिमित्रिस इलियाडिस

@JimIliadis "var" और "string" का अर्थ इस मामले में बिल्कुल समान है - संकलक यह जानने के लिए पर्याप्त स्मार्ट है कि परिणाम केवल 'string' हो सकता है। var वास्तव में सिर्फ एक कोडिंग स्टाइल चीज़ है (जब गुमनाम प्रकारों का उपयोग नहीं किया जा रहा है)

— डेव बिश

बहुत पुराने सूत्र पर टिप्पणी करना, लेकिन इस पर एक अपवाद पाया गया। जब आप फ़र्स्टडफ़ॉल्ट () का उपयोग करते हैं, तो सुनिश्चित करें कि यह डिफ़ॉल्ट मान भी लौटा सकता है। तो, मान लीजिए कि आप एक एम्पायर स्ट्रिंग पास कर रहे हैं, अर्थात् मिस्ट्रिंग = "" और आप दिखाने के लिए कुछ भी नहीं होने की उम्मीद कर रहे हैं, लेकिन फिर भी यह सूची के पहले आइटम को प्रदर्शित करेगा क्योंकि आपने फ़र्स्टडफ़ॉल्ट चुना है।

— डर्टी डेवलपर

@ डीडीड्यूपर यह सुनिश्चित नहीं करता है कि आप इसका क्या मतलब है - आपका उदाहरण शून्य हो जाएगा, अगर लक्ष्य सूची में कोई खाली तार नहीं थे। यदि आप संरचना प्रकार पर FirstOrDefault () का उपयोग करने का प्रयास कर रहे हैं तो आप सही हैं, उदाहरण के लिए सूची <int> - FirstOrDefault () '0' लौटाएगा और अशक्त नहीं होगा - हालाँकि, सवाल विशेष रूप से तार के बारे में था

— डेवले

Answer 2

मूल उत्तर है: आपको लूप के माध्यम से पुनरावृति करने और किसी भी तत्व को निर्दिष्ट स्ट्रिंग की जांच करने की आवश्यकता है। तो, मान लें कि कोड है:

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

समतुल्य, लेकिन इसके विपरीत, कोड है:

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

यहाँ, x एक पैरामीटर है जो उपरोक्त कोड में "आइटम" की तरह कार्य करता है।

Answer 3

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

Answer 4

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

पुराने फैशन लूप लगभग हमेशा सबसे तेज होते हैं।

Comments

चूंकि मैं दक्षता के लिए जाता हूं, क्या आप यह सुझाव दे रहे हैं कि यह विधि तेज है (इस प्रकार, अधिक कुशल)?

— दिमित्री इलियाडिस

मैंने इसका परीक्षण नहीं किया है, लेकिन मुझे लगता है कि यह तेज़ होगा। केवल सूची में से किसी एक को पास करने की आवश्यकता होती है, जब तक कि यह कुछ न पा ले और जल्दी टूट जाता है (जैसे कि लिनक विकल्प शायद अच्छी तरह से लिखा जाए), तो लिनक की उपरि उपविधि, या लिनक के लैम्ब्डा ओवरहेड की विधि नहीं है। ऐसा नहीं है कि वे चिंता का बड़ा कारण हैं, लेकिन कुछ प्रदर्शन हिट हो सकते हैं।

— मैके

List.Equals () का उपयोग क्यों नहीं करते?

— F8ER

@ V.7 क्योंकि वह केवल यह जानना चाहता है कि सूची में एक आइटम में एक विकल्प है। list.equals नौकरी के लिए सही उपकरण नहीं है ["abc", "def", "ghi"] में "hi" होता है जिस तरह से ओपी इसका वर्णन करता है। list.equals सही डेटाटाइप भी नहीं लेता है।

— मैकके

Answer 5

यदि आप अपने तार वाले तार की एक सूची चाहते हैं:

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

एक अन्य विकल्प Linq FirstOrDefault का उपयोग करना है

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

ध्यान रखें कि Containsविधि संवेदनशील है।

Comments

केस सेंसिटिव के बारे में अच्छा रिमाइंडर, StringComparison.InvariantCultureIgnoreCase

— जोशेट्स 1980

Answer 6

आप Linq की FirstOrDefaultएक्सटेंशन विधि का उपयोग कर सकते हैं :

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

यह मुट्ठी तत्व को प्रतिस्थापित करेगा जिसमें सबस्ट्रिंग शामिल है myString, या nullयदि ऐसा कोई तत्व नहीं मिला है।

यदि आप सभी की जरूरत सूचकांक है, List<T>वर्ग FindIndexविधि का उपयोग करें:

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

यह मुट्ठी तत्व के सूचकांक को लौटाएगा जिसमें सबस्ट्रिंग शामिल है myString, या -1यदि ऐसा कोई तत्व नहीं मिला है।

Answer 7

कई अच्छी यहाँ का जवाब देता है, लेकिन मैं का उपयोग कर एक साधारण से एक का उपयोग मौजूद है , नीचे के रूप में:

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 8

आप इस तरह से कुछ का उपयोग करने में सक्षम होना चाहिए, यह मेरे लिए ठीक काम किया है:

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

या ऐसा कुछ, अगर आपको यह देखने की जरूरत है कि यह कहां से मेल नहीं खाता है।

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

Answer 9

आप उपयोग कर सकते हैं

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

LINQ आपको डेटा के किसी भी संग्रह को "क्वेरी" करने की क्षमता प्रदान करता है। आप एक संग्रह पर डेटाबेस डेटाबेस क्वेरी (चुनें, जहां, आदि) की तरह सिंटैक्स का उपयोग कर सकते हैं (यहां स्ट्रिंग्स का संग्रह (सूची))।

तो आप ऐसा कर रहे हैं "मुझे सूची से आइटम प्राप्त करें जहां यह किसी दिए गए शर्त को पूरा करता है"

अंदर जहाँ आप एक "लैंबडा एक्सप्रेशन" का उपयोग कर रहे हैं

संक्षेप में बताएं कि लैम्ब्डा अभिव्यक्ति कुछ इस तरह है (इनपुट पैरामीटर => रिटर्न वैल्यू)

तो एक पैरामीटर "आइटम" के लिए, यह "आइटम। कॉन्टैक्ट्स (" आवश्यक स्ट्रिंग ")" "लौटाता है। तो यह सही है अगर आइटम में स्ट्रिंग शामिल है और इस तरह यह सूची से चयनित हो जाता है क्योंकि यह स्थिति को संतुष्ट करता है।

Answer 10

इसे सरल उपयोग रखने के लिए;

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

वैकल्पिक रूप से, लूप के साथ ऐसा करने के लिए, इसका उपयोग करें;

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

Comments

बस इंगित करने के लिए, आप कोड की पंक्तियों में से एक से एक अंत कोष्ठक से चूक गए .. अगर (आइटम। कॉन्सर्ट ("खोज शब्द"))

— एलेक्स

Answer 11

मैंने अन्य उत्तरों में बूल विकल्प नहीं देखा है, इसलिए मुझे उम्मीद है कि नीचे दिए गए कोड से किसी को मदद मिलेगी।

महज प्रयोग करें Any()

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

Answer 12

यह किसी भी, जहां, पहले और FirstOrDefault को संयोजित करना संभव है; या बस उन तरीकों में से किसी में विधेय को रखें जो कि आवश्यक हो।

जब तक आप कोई मैच नहीं मिल जाता है तब तक आपको पहले अपवाद का उपयोग करने से बचना चाहिए। FirstOrDefault आमतौर पर बेहतर विकल्प है जब तक आप जानते हैं कि यह टाइप का डिफ़ॉल्ट लौटा देगा यदि कोई मैच नहीं मिला (स्ट्रिंग का डिफ़ॉल्ट शून्य है, int 0 है, बूल गलत है, आदि)।

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

इस कोड का परीक्षण करें @ https://rextester.com/TXDL57489