सूची <T> और आईनेमेरेबल <T>

Question

के बीच स्वतंत्र रूप से परिवर्तित करें मैं List<MyObject> को IEnumerable<MyObject> पर फिर से कैसे परिवर्तित कर सकता हूं और फिर वापस आ सकता हूं?

मैं सूची में LINQ कथन की एक श्रृंखला चलाने के लिए ऐसा करना चाहता हूं, ई। जी। Sort()

Answer 1

List<string> myList = new List<string>(); 
IEnumerable<string> myEnumerable = myList; 
List<string> listAgain = myEnumerable.ToList(); 

Answer 2

एक तरफ: ध्यान दें कि मानक LINQ ऑपरेटरों (पहले उदाहरण के अनुसार) मौजूदा सूची में परिवर्तन नहीं करते - list.OrderBy(...).ToList() फिर से आदेश दिया अनुक्रम के आधार पर एक नई सूची बनाने होंगे।

static void Sort<TSource, TValue>(this List<TSource> list, 
    Func<TSource, TValue> selector) 
{ 
    var comparer = Comparer<TValue>.Default; 
    list.Sort((x,y) => comparer.Compare(selector(x), selector(y))); 
} 

static void SortDescending<TSource, TValue>(this List<TSource> list, 
    Func<TSource, TValue> selector) 
{ 
    var comparer = Comparer<TValue>.Default; 
    list.Sort((x,y) => comparer.Compare(selector(y), selector(x))); 
} 

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

list.Sort(x=>x.SomeProp); // etc 

यह वही में मौजूदा सूची अद्यतन करता है यह बहुत आसान है, तथापि, एक विस्तार विधि है कि आप List<T>.Sort साथ lambdas उपयोग करने के लिए अनुमति देता है बनाने के लिए किया जाता है जिस तरह से List<T>.Sort आमतौर पर करता है।

Answer 3

ए List<T>IEnumerable<T> है, इसलिए वास्तव में, List<T> को IEnumerable<T> पर 'रूपांतरित करने' की आवश्यकता नहीं है। चूंकि List<T>IEnumerable<T> है, तो आप IEnumerable<T> प्रकार के चर के लिए List<T> असाइन कर सकते हैं।

दूसरी तरह के आसपास, नहीं हर IEnumerable<T> एक List<T> offcourse है, इसलिए तो आप IEnumerable<T> की ToList() सदस्य विधि कॉल करना होगा।

Answer 4

ए List<T> पहले से ही IEnumerable<T> है, इसलिए आप सीधे अपने List<T> चर पर LINQ कथन चला सकते हैं।

यदि आपको LINQ एक्सटेंशन विधियों जैसे OrderBy() नहीं दिखाई दे रहा है, तो मुझे लगता है कि आपके पास आपकी स्रोत फ़ाइल में using System.Linq निर्देश नहीं है।

आप एक List<T> स्पष्ट रूप से करने के लिए वापस LINQ अभिव्यक्ति परिणाम कन्वर्ट करने के लिए हालांकि की आवश्यकता है:

List<Customer> list = ... 
list = list.OrderBy(customer => customer.Name).ToList() 

Answer 5

स्मृति में दोहराव को रोकने के लिए, Resharper यह सुझाव है:

List<string> myList = new List<string>(); 
IEnumerable<string> myEnumerable = myList; 
List<string> listAgain = myList as List<string>() ?? myEnumerable.ToList(); 

.ToList() एक नई अपरिवर्तनीय सूची देता है। तो सूची में परिवर्तनअन्यैन @Lamas Czinege उत्तर में myList को प्रभावित नहीं करता है। अधिकांश मामलों में यह कम से कम दो कारणों में सही है: इससे दूसरे क्षेत्र (ढीले युग्मन) को प्रभावित करने वाले एक क्षेत्र में परिवर्तनों को रोकने में मदद मिलती है, और यह बहुत पठनीय है, क्योंकि हमें संकलक चिंताओं के साथ कोड तैयार नहीं करना चाहिए।

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

Answer 6

List(T) कक्षा IEnumerable(T) लागू करता है (और आईएलआईस्ट (टी), आईसीओलेक्शन (टी), आईन्यूमेरेबल (टी) जैसे कई अन्य लोगों को इसलिए सूची को वापस आईन्यूमेरेबल में बदलने की आवश्यकता नहीं है।

public class Person 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

Person person1 = new Person() { Id = 1, Name = "Person 1" }; 
Person person2 = new Person() { Id = 2, Name = "Person 2" }; 
Person person3 = new Person() { Id = 3, Name = "Person 3" }; 

List<Person> people = new List<Person>() { person1, person2, person3 }; 

//Converting to an IEnumerable 
IEnumerable<Person> IEnumerableList = people; 

लेकिन IEnumerable से कन्वर्ट करने के लिए सूची के लिए एक वैध परिदृश्य

IEnumerable<Person> OriginallyIEnumerable = new List<Person>() { person1, person2 }; 
List<Person> convertToList = OriginallyIEnumerable.ToList(); 

यह Entity Framework में उपयोगी है।