C # में सूची से आइटम कैसे निकालें?

Question

मेरे पास परिणाम सूची में संग्रहीत सूची इस प्रकार है:

var resultlist = results.ToList();

यह कुछ इस तरह दिखता है:

ID FirstName  LastName
-- ---------  --------
1  Bill       Smith
2  John       Wilson
3  Doug       Berg

मैं सूची से ID 2 कैसे निकालूं?

Answer 1

List<T> दो तरीके हैं जिनका आप उपयोग कर सकते हैं।

यदि आप आइटम का इंडेक्स जानते हैं तो RemoveAt (int index) का उपयोग किया जा सकता है। उदाहरण के लिए:

resultlist.RemoveAt(1);

या आप निकालें (टी आइटम) का उपयोग कर सकते हैं :

var itemToRemove = resultlist.Single(r => r.Id == 2);
resultList.Remove(itemToRemove);

जब आप सुनिश्चित नहीं होते हैं कि आइटम वास्तव में मौजूद है तो आप सिंगलऑर्फ़ॉल्ट का उपयोग कर सकते हैं । अगर कोई आइटम नहीं है तो SingleOrDefaultवापस आ जाएगा null( Singleजब वह आइटम नहीं मिल सकता है तो एक अपवाद फेंक देगा)। डुप्लिकेट वैल्यू (समान के साथ दो आइटम id) होने पर दोनों फेंक देंगे ।

var itemToRemove = resultlist.SingleOrDefault(r => r.Id == 2);
if (itemToRemove != null)
    resultList.Remove(itemToRemove);

Comments

अच्छी तरह से, शायदvar itemsToRemove = resultlist.Where(r => r.Id == 2); foreach (var itemToRemove in ItemsToRemove) resultList.Remove(itemToRemove);

— व्लाद

यह नहीं होना चाहिए resultlist.Items.RemoveAt(1);?

— ड्रीमटाइक

Answer 2

संक्षिप्त उत्तर:
_{निकालें (सूची से results)}

results.RemoveAll(r => r.ID == 2);साथ आइटम को हटा देगा आईडी 2 में results(जगह में)।

_{फ़िल्टर (मूल सूची से निकाले बिना results):}

var filtered = result.Where(f => f.ID != 2);आईडी 2 के साथ वाले को छोड़कर सभी आइटम लौटाता है

विस्तृत जवाब:

मुझे लगता .RemoveAll()है कि बहुत लचीला है, क्योंकि आपके पास आइटम आईडी की एक सूची हो सकती है जिसे आप निकालना चाहते हैं - कृपया निम्नलिखित उदाहरण के बारे में सोचें ।

यदि आपके पास है:

class myClass {
    public int ID; public string FirstName; public string LastName;
}

और कुछ मान resultsइस प्रकार हैं:

var results=new List<myClass> {
    new myClass()  { ID=1, FirstName="Bill", LastName="Smith" },
    new myClass()  { ID=2, FirstName="John", LastName="Wilson" },
    new myClass()  { ID=3, FirstName="Doug", LastName="Berg" },
    new myClass()  { ID=4, FirstName="Bill", LastName="Wilson" },
};

फिर आप हटाने के लिए आईडी की एक सूची परिभाषित कर सकते हैं:

var removeList = new List<int>() { 2, 3 };

और उन्हें हटाने के लिए बस इसका उपयोग करें:

results.RemoveAll(r => removeList.Any(a => a==r.ID));

यह आइटम 2 और 3 को हटा देगा और आइटम 1 और 4 को रखेगा - जैसा कि निर्दिष्ट किया गया है removeList। ध्यान दें कि यह जगह में होता है, इसलिए किसी भी अतिरिक्त जमाव की आवश्यकता नहीं है।

बेशक, आप इसे एकल आइटम पर भी उपयोग कर सकते हैं जैसे:

results.RemoveAll(r => r.ID==4);

जहां यह हमारे उदाहरण में ID 4 के साथ बिल को हटा देगा।

---

DotNetField: डेमो चलाएँ

Answer 3

resultList = results.Where(x=>x.Id != 2).ToList();

थोड़ा लिनेक हेल्पर है जो मुझे पसंद है कि इसे लागू करना आसान है और "जहां नहीं" शर्तों के साथ प्रश्न करना आसान बना सकते हैं:

public static IEnumerable<T> ExceptWhere<T>(this IEnumerable<T> source, Predicate<T> predicate)
{
    return source.Where(x=>!predicate(x));
}

//usage in above situation
resultList = results.ExceptWhere(x=>x.Id == 2).ToList();

Comments

एक अन्य समान दृष्टिकोण (जो एक विधेय का उपयोग करता है) का उपयोग करना है List.FindIndex/ List.RemoteAt(जिसमें "म्यूट" है या "म्यूटिंग ऑपरेशन होने की" इतनी अच्छी "सुविधा नहीं है")।

यह सच है, लेकिन कह रही है कि सूची के ऑपरेशन के बारे में सावधान रहना है परिवर्तनशील। सूची दृश्यों के पीछे एक सरणी का उपयोग करती है, और यह आवश्यक होने पर छोटे या बड़े क्षमता के साथ अपने सरणी को फिर से बना सकती है। आमतौर पर , हटाना मौजूदा सरणी का एक इन-प्लेस म्यूटेशन है।

— कीथ्स

यह सुरक्षित नहीं है, और इसकी सादगी के लिए आप सिर्फ सिंगलऑर्फ़ॉल्ट का उपयोग कर सकते हैं, इसे स्थिर विधि में समाहित करने की आवश्यकता नहीं है

किसी ने नहीं कहा कि यह थ्रेड-सेफ था (और क्या यह इस बात पर निर्भर करता है कि थ्रेड्स क्या करने वाले हैं; यह वास्तव में वर्कर थ्रेड को अलग-अलग मेमोरी-मेमोरी कंस्ट्रक्शन देने के लिए बेहतर हो सकता है। या उन्हें एक समवर्ती संग्रह पर सभी काम करने दें। ), और ओपी चाहता है कि सभी रिकॉर्ड्स को छोड़कर एक मेल को विधेय से जोड़ा जाए, इसलिए SingleOrDefault वास्तव में वही लौटेगा जो वह नहीं चाहता है। "स्टैटिक मेथड" वास्तव में एक विस्तार विधि है, जैसे कि अधिकांश लिनक, और यह तब काम करता है जब आप जो नहीं चाहते हैं (एक तत्व या कई) जो आप करते हैं उससे अधिक परिभाषित करना आसान है।

— कीथ्स

Answer 4

एक और दृष्टिकोण है। यह उपयोग करता है List.FindIndexऔर List.RemoveAt।

जब मैं होता शायद समाधान Keiths द्वारा प्रस्तुत (सिर्फ सरल का उपयोग Where/ ToListकि यह में) इस दृष्टिकोण अलग है mutates मूल सूची वस्तु। यह उम्मीदों के आधार पर एक अच्छा (या बुरा) "फीचर" हो सकता है।

किसी भी मामले में, FindIndex(गार्ड के साथ युग्मित) यह सुनिश्चित करता RemoveAtहै कि आईडी में अंतराल हैं या ऑर्डर गलत है, आदि के कारण वसीयत सही है, और सूची के माध्यम से RemoveAt(बनाम Remove) एक दूसरे ओ (एन) खोज से बचा जाता है ।

यहाँ एक LINQPad स्निपेट है:

var list = new List<int> { 1, 3, 2 };
var index = list.FindIndex(i => i == 2); // like Where/Single
if (index >= 0) {   // ensure item found
    list.RemoveAt(index);
}
list.Dump();        // results -> 1, 3

खुश कोडिंग।

Answer 5

आप निर्दिष्ट नहीं करते कि किस प्रकार की सूची है, लेकिन सामान्य सूची RemoveAt(index)विधि, या विधि का उपयोग कर सकती है Remove(obj):

// Remove(obj)
var item = resultList.Single(x => x.Id == 2);
resultList.Remove(item);

// RemoveAt(index)
resultList.RemoveAt(1);

Answer 6

अधिक सरलीकृत:

resultList.Remove(resultList.Single(x => x.Id == 2));

कोई नई var ऑब्जेक्ट बनाने की कोई आवश्यकता नहीं है।

Answer 7

... या सिर्फ resultlist.RemoveAt(1)अगर आप वास्तव में सूचकांक जानते हैं।

Answer 8

{
    class Program
    {
        public static List<Product> list;
        static void Main(string[] args)
        {

            list = new List<Product>() { new Product() { ProductId=1, Name="Nike 12N0",Brand="Nike",Price=12000,Quantity=50},
                 new Product() { ProductId =2, Name = "Puma 560K", Brand = "Puma", Price = 120000, Quantity = 55 },
                 new Product() { ProductId=3, Name="WoodLand V2",Brand="WoodLand",Price=21020,Quantity=25},
                 new Product() { ProductId=4, Name="Adidas S52",Brand="Adidas",Price=20000,Quantity=35},
                 new Product() { ProductId=5, Name="Rebook SPEED2O",Brand="Rebook",Price=1200,Quantity=15}};


            Console.WriteLine("Enter ProductID to remove");
            int uno = Convert.ToInt32(Console.ReadLine());
            var itemToRemove = list.Find(r => r.ProductId == uno);
            if (itemToRemove != null)
                list.Remove(itemToRemove);
            Console.WriteLine($"{itemToRemove.ProductId}{itemToRemove.Name}{itemToRemove.Brand}{itemToRemove.Price}{ itemToRemove.Quantity}");
            Console.WriteLine("------------sucessfully Removed---------------");

            var query2 = from x in list select x;
            foreach (var item in query2)
            {
                /*Console.WriteLine(item.ProductId+" "+item.Name+" "+item.Brand+" "+item.Price+" "+item.Quantity );*/
                Console.WriteLine($"{item.ProductId}{item.Name}{item.Brand}{item.Price}{ item.Quantity}");
            }

        }

    }
}