सी # 2.0

Question

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

जो मैं प्राप्त करने का प्रयास कर रहा हूं वह यह पता लगाने के लिए है कि किसी यूएसबी डिवाइस को कंप्यूटर से कनेक्ट करने के बाद कौन सा ड्राइव बनाया गया था।

// Get list of removable drives before user connects the USB cable 
List<string> listRemovableDrivesBefore = GetRemovableDriveList(); 

// Tell user to connect USB cable 
... 

// Start listening for a connection of a USB device 
... 

// Loop until device is connected or time runs out 
do 
{ 
    ... 
} while 

// Get list of removable drives after USB device is connected 
List<string> listRemovableDrivesAfter = GetRemovableDriveList(); 

// Find out which drive was created after USB has been connected 
??? 

GetRemovableDriveList निकाले जाने योग्य ड्राइव पत्र के स्ट्रिंग की एक सूची देता है:

यहाँ सरलीकृत कार्यप्रवाह है। मेरा विचार से पहले हटाने योग्य ड्राइव की सूची प्राप्त करना था, और के बाद यह एक और सूची है, और यह दूसरी सूची से पहले सूची की सामग्री को हटाकर, मुझे ड्राइव के साथ छोड़ा जाएगा बस जुड़े थे (आमतौर पर केवल एक)।

लेकिन मुझे दूसरे से एक सूची "घटाना" का एक आसान तरीका नहीं मिल रहा है। कोई भी समाधान का सुझाव दे सकता है, या जो भी मैं करने की कोशिश कर रहा हूं उसे हासिल करने का एक बेहतर तरीका भी सुझा सकता हूं।

नोट: परियोजना .NET Framework 2.0 को लक्षित कर रही है, इसलिए कोई LINQ संभव नहीं है।

धन्यवाद!

Answer 1

तो तत्वों की एक छोटी संख्या एक Contains कॉल के साथ एक foreach पाश चाल करना चाहिए लिए: यदि आप एक Dictionary<K,V> का उपयोग कर के बजाय द्वारा लुकअप और अधिक कुशल बनाने सकता संग्रह तो कई तत्व है

List<string> listRemovableDrivesBefore = GetRemovableDriveList(); 
// ... 
List<string> listRemovableDrivesAfter = GetRemovableDriveList(); 

List<string> addedDrives = new List<string>(); 
foreach (string s in listRemovableDrivesAfter) 
{ 
    if (!listRemovableDrivesBefore.Contains(s)) 
     addedDrives.Add(s); 
} 

हैं एक List<T>। (आदर्श रूप में आप HashSet<T> का उपयोग करेंगे, लेकिन यह ढांचे के संस्करण 2 में उपलब्ध नहीं है।)

Answer 2

ऐसा करने का एक सामान्य तरीका स्रोत संग्रह से सभी वस्तुओं को एक शब्दकोश में जोड़ना होगा और फिर आइटम को हटा देना होगा अन्य संग्रह:

public static IEnumerable<T> Subtract<T>(IEnumerable<T> source, IEnumerable<T> other) 
{ 
    return Subtract(source, other, EqualityComparer<T>.Default); 
} 

public static IEnumerable<T> Subtract<T>(IEnumerable<T> source, IEnumerable<T> other, IEqualityComparer<T> comp) 
{ 
    Dictionary<T, object> dict = new Dictionary<T, object>(comp); 
    foreach(T item in source) 
    { 
     dict[item] = null; 
    } 

    foreach(T item in other) 
    { 
     dict.Remove(item); 
    } 

    return dict.Keys; 
} 

Answer 3

आप Linq विस्तार विधि के घटाना और Insersect साथ काम कर सकते एक ही रूप में यदि आप गणित सेट के साथ करते हैं।

ए = मूल।

बी = बाद में।

ए - (ए इंटरसेक्ट बी) = मूल बी से हटा - नई

वर (ए insersect बी) = एक दूसरे को काटना = A.Intersect (बी);

var हटाया गया = ए। सब्सट्रेट (छेड़छाड़); var new = B.Substract (intersect)

आशा है कि यह आपके लिए काम करता है।