इकाई का निर्माण LINQ में एंटिटीज क्वेरी के लिए नहीं किया जा सकता है

Question

एक इकाई प्रकार नामक उत्पाद है जो इकाई ढांचे द्वारा उत्पन्न होता है। मैंने यह क्वेरी लिखी है

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}

नीचे दिया गया कोड निम्नलिखित त्रुटि फेंकता है:

"इकाई या जटिल प्रकार Shop.Product एक LINQ में इकाई क्वेरी के लिए नहीं बनाया जा सकता है"

var products = productRepository.GetProducts(1).Tolist();

लेकिन जब मैं select pइसके बजाय उपयोग select new Product { Name = p.Name};करता हूं तो सही तरीके से काम करता है।

मैं कस्टम चयन अनुभाग को कैसे बेहतर बना सकता हूं?

Comments

System.NotSupportedException: 'एंटिटी या जटिल प्रकार' StudentInfoAjax.Models.Student 'को LINQ में Entities क्वेरी में नहीं बनाया जा सकता है।'

— एमडी वाहिद

Answer 1

आप मैप की गई इकाई पर प्रोजेक्ट नहीं कर सकते (और करने में सक्षम नहीं होना चाहिए)। हालाँकि, आप अनाम प्रकार या DTO पर प्रोजेक्ट कर सकते हैं :

public class ProductDTO
{
    public string Name { get; set; }
    // Other field you may need from the Product entity
}

और आपका तरीका डीटीओ की सूची वापस कर देगा।

public List<ProductDTO> GetProducts(int categoryID)
{
    return (from p in db.Products
            where p.CategoryID == categoryID
            select new ProductDTO { Name = p.Name }).ToList();
}

Comments

मुझे समझ में नहीं आ रहा है कि मुझे ऐसा करने में सक्षम क्यों नहीं होना चाहिए ... यह बहुत उपयोगी होगा ...

— जोन्क्स

EF में मैप की गई संस्थाएं मूल रूप से डेटाबेस टेबल का प्रतिनिधित्व करती हैं। यदि आप एक मैप की गई इकाई पर प्रोजेक्ट करते हैं, तो आप मूल रूप से जो करते हैं, वह आंशिक रूप से एक इकाई को लोड करता है, जो कि एक मान्य स्थिति नहीं है। EF को भविष्य में इस तरह की इकाई के एक अद्यतन को संभालने के लिए कोई सुराग नहीं होगा (डिफ़ॉल्ट व्यवहार संभवत: गैर-लोड किए गए फ़ील्ड को नल से या आपकी वस्तु में जो भी आपके पास होगा) को अधिलेखित कर देगा। यह एक खतरनाक ऑपरेशन होगा, क्योंकि आप अपने कुछ डेटा को DB में खोने का जोखिम उठा सकते हैं, इसलिए इसे EF में आंशिक रूप से लोड संस्थाओं (या मैप की गई संस्थाओं पर प्रोजेक्ट) की अनुमति नहीं है।

— याकिमिक

@Yakimych जो यह समझ में आता है कि अगर आपके पास कोई समग्र इकाई है जो आप एक क्वेरी के माध्यम से उत्पन्न / बना रहे हैं और इसलिए पूरी तरह से अवगत हैं / एक नई इकाई बनाने का इरादा रखते हैं जिसे आप फिर जोड़ तोड़ और बाद में जोड़ देंगे। इस स्थिति में आपको या तो क्वेरी चलाने के लिए मजबूर करना होगा या एक डटो में धकेलना होगा और एक इकाई में वापस जोड़ना होगा - जो कि निराशाजनक है

— Cargowire

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

— याकिमिक

डीटीओ - डेटा ट्रांसफर ऑब्जेक्ट्स

— tkerwood

Answer 2

आप गुमनाम प्रकार में प्रोजेक्ट कर सकते हैं, और फिर इसे मॉडल प्रकार से

public IEnumerable<Product> GetProducts(int categoryID)
{
    return (from p in Context.Set<Product>()
            where p.CategoryID == categoryID
            select new { Name = p.Name }).ToList()
           .Select(x => new Product { Name = x.Name });
}

संपादित करें : मैं थोड़ा अधिक विशिष्ट होने जा रहा हूं क्योंकि इस प्रश्न पर बहुत ध्यान दिया गया।

आप सीधे मॉडल प्रकार (ईएफ प्रतिबंध) में प्रोजेक्ट नहीं कर सकते हैं, इसलिए इसके आसपास कोई रास्ता नहीं है। एकमात्र तरीका गुमनाम प्रकार (1 पुनरावृत्ति) में प्रोजेक्ट करना है, और फिर मॉडल प्रकार (2 पुनरावृत्ति) के लिए।

कृपया इस बात से भी अवगत रहें कि जब आप आंशिक रूप से संस्थाओं को इस तरह से लोड करते हैं, तो उन्हें अपडेट नहीं किया जा सकता है, इसलिए उन्हें अलग रहना चाहिए, जैसे वे हैं।

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

ऊपर दी गई विधि पर विचार करें: हमारे पास अभी भी एक आंशिक रूप से भरी हुई मॉडल इकाई है। यह इकाई अलग है।

इस पर विचार करें (इच्छा-से-मौजूद) संभव कोड:

return (from p in Context.Set<Product>()
        where p.CategoryID == categoryID
        select new Product { Name = p.Name }).AsNoTracking().ToList();

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

Comments

यह सबसे साफ समाधान है जब आपको उस चयनित इकाई की स्थिति के बारे में ज़रूरत नहीं है / परवाह नहीं है जिसे आप प्रोजेक्ट करना चाहते हैं।

— मायरो मायरेलस

और जब आप परवाह नहीं करते हैं यदि आप IEnumerable या IQueryable;) लौटाते हैं। लेकिन फिर भी आप मेरे उत्थान का कारण बनते हैं क्योंकि यह समाधान अब मेरे लिए काम करता है।

— माइकल ब्रेन्ट

तकनीकी रूप से, मॉडल प्रकार का प्रक्षेपण क्वेरी के बाहर हो रहा है, और मेरा मानना ​​है कि सूची के माध्यम से एक अतिरिक्त पुनरावृत्ति की भी आवश्यकता है। मैं अपने कोड के लिए इस समाधान का उपयोग नहीं करूंगा, लेकिन यह प्रश्न के लिए समाधान है। इजाफा।

— सी

मैं स्वीकार किए जाते हैं डीटीओ समाधान को यह पसंद करते हैं - और अधिक सुंदर और स्वच्छ

— एडम अरे

सिवाय इसके कि, सम्मान के साथ, यह वास्तव में सवाल का जवाब नहीं है। यह एक उत्तर है कि Linq To Objects प्रोजेक्शन कैसे किया जाता है, न कि Linq से Entities क्वेरी प्रोजेक्शन। तो DTO विकल्प एकमात्र विकल्प re: Linq to Entities है।

— रिस्म

Answer 3

एक और तरीका है जो मुझे काम करता है, आपको एक वर्ग बनाना होगा जो आपके उत्पाद वर्ग से प्राप्त होता है और इसका उपयोग करता है। उदाहरण के लिए:

public class PseudoProduct : Product { }

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products
           where p.CategoryID== categoryID
           select new PseudoProduct() { Name = p.Name};
}

यकीन नहीं होता कि यह "अनुमति" है, लेकिन यह काम करता है।

Comments

चतुर! अब यह कोशिश की और यह काम करता है। मुझे यकीन है कि यह किसी तरह मुझे जला देगा, हालांकि।

— डैनियल

BTW यह आपको काटता है यदि आप GetProducts के परिणामों को जारी रखने की कोशिश करते हैं () क्योंकि EF PseudoProduct जैसे "System.InvalidOperationException: मैपिंग और मेटाडाटा जानकारी के लिए मैपिंग नहीं ढूँढ सकता है, तो EntityType 'blah.PseudoProduct' के लिए खोजा नहीं जा सकता।

— मुस्कुराते हुए

सर्वश्रेष्ठ उत्तर, और केवल वही जो प्रश्न के मापदंडों के भीतर उत्तर देता है। अन्य सभी उत्तर रिटर्न प्रकार को बदलते हैं या समय से पहले IQueryable को निष्पादित करते हैं और वस्तुओं को linq का उपयोग करते हैं

— rdans

100% हैरान यह काम किया ... EF 6.1 में यह काम कर रहा है।

— ट्रैविसवाइड

@mejobloggs कोशिश करें [व्युत्पन्न] व्युत्पन्न वर्ग पर विशेषता, या .Ignore <T> यदि आप धाराप्रवाह एपीआई का उपयोग कर रहे हैं।

— डंक

Answer 4

यहाँ एक तरीका यह है कि बिना किसी विशेष वर्ग की घोषणा किए:

public List<Product> GetProducts(int categoryID)
{
    var query = from p in db.Products
            where p.CategoryID == categoryID
            select new { Name = p.Name };
    var products = query.ToList().Select(r => new Product
    {
        Name = r.Name;
    }).ToList();

    return products;
}

हालाँकि, इसका उपयोग केवल तभी किया जा सकता है यदि आप एक इकाई में कई संस्थाओं को संयोजित करना चाहते हैं। उपरोक्त कार्यक्षमता (उत्पाद मानचित्रण के लिए सरल उत्पाद) इस तरह किया जाता है:

public List<Product> GetProducts(int categoryID)
{
    var query = from p in db.Products
            where p.CategoryID == categoryID
            select p;
    var products = query.ToList();

    return products;
}

Answer 5

एक और सरल तरीका :)

public IQueryable<Product> GetProducts(int categoryID)
{
    var productList = db.Products
        .Where(p => p.CategoryID == categoryID)
        .Select(item => 
            new Product
            {
                Name = item.Name
            })
        .ToList()
        .AsQueryable(); // actually it's not useful after "ToList()" :D

    return productList;
}

Comments

अच्छी बात यह है कि मैंने अभी आपके अच्छे उत्तर के साथ कुछ IQueryable सीखा है। यह अच्छा किया गया है, हालांकि अगर आप क्यों यह एक ToList के बाद उपयोगी नहीं है () के बारे में बताया है | और कारण यह है कि आप एक LINQ करने वाली SQL क्वेरी में सामान्य सूचियों का उपयोग नहीं कर सकता है जाएगा। इसलिए यदि आप जानते हैं कि आप हमेशा कॉलर द्वारा परिणाम को किसी अन्य क्वेरी में पुश करने वाले हैं, तो निश्चित रूप से IQueryable होने का अर्थ है। लेकिन यदि नहीं ... यदि आप इसे एक सामान्य सूची के रूप में उपयोग करने वाले हैं, तो विधि के अंदर ToList () का उपयोग करें ताकि आप इस विधि पर प्रत्येक और हर कॉल IQueryable पर नहीं कर रहे हैं।

— पॉजिटिव

आपने मेरे मित्र को पूरी तरह से ठीक कर दिया है। मैं सिर्फ प्रश्न पद्धति के हस्ताक्षर की नकल करता हूं, क्योंकि मैं इसे क्वैरी-सक्षम में परिवर्तित करता हूं ...;)

— सोरेन

यह काम करता है, प्रोडक्टलिस्ट ToList () के बाद अप्राप्य हो जाता है। मैं इसे संपादन योग्य कैसे बना सकता हूं?

— doncadavona

यदि आप .ToListक्वेरी में डालते हैं , तो इसे सर्वर से डेटा निष्पादित और खींचा जाता है फिर इसे फिर से बनाने का क्या मतलब है AsQueryable?

— मोशी

@Moshii केवल विधि वापसी प्रकार के हस्ताक्षर को संतुष्ट करने के लिए, (जैसा कि मैंने उत्तर में कहा, यह अब उपयोगी नहीं है)।

— सोरेन

Answer 6

आप इसका उपयोग कर सकते हैं और यह काम करना चाहिए -> toListनई सूची का चयन करने से पहले आपको इसका उपयोग करना चाहिए :

db.Products
    .where(x=>x.CategoryID == categoryID).ToList()
    .select(x=>new Product { Name = p.Name}).ToList(); 

Comments

हालांकि यह अभी भी एक 'SELECT * FROM [..]' करेगा, न कि 'SELECT name FROM [..]'

— टिमो हरमन्स

Answer 7

अन्य प्रश्न के उत्तर में जिसे डुप्लिकेट के रूप में चिह्नित किया गया था ( यहां देखें ) मैंने सोरेन के उत्तर के आधार पर एक त्वरित और आसान समाधान का पता लगाया:

data.Tasks.AddRange(
    data.Task.AsEnumerable().Select(t => new Task{
        creator_id   = t.ID,
        start_date   = t.Incident.DateOpened,
        end_date     = t.Incident.DateCLosed,
        product_code = t.Incident.ProductCode
        // so on...
    })
);
data.SaveChanges();

नोट: यह समाधान केवल तभी काम करता है जब आपके पास टास्क क्लास (यहां 'हादसा' कहा जाता है) पर एक नेविगेशन संपत्ति (विदेशी कुंजी) है। यदि आपके पास ऐसा नहीं है, तो आप "AsQueryable ()" के साथ अन्य पोस्ट किए गए समाधानों में से किसी एक का उपयोग कर सकते हैं।

Answer 8

आप डेटा ट्रांसफर ऑब्जेक्ट्स (DTO) का उपयोग करके इसे हल कर सकते हैं।

ये व्यूमाडल्स की तरह थोड़े होते हैं, जहाँ आप अपनी ज़रूरत के गुणों को डालते हैं और आप इन्हें अपने कंट्रोलर में या ऑटोमैपर जैसे थर्ड-पार्टी सॉल्यूशंस का उपयोग करके मैन्युअल रूप से मैप कर सकते हैं।

डीटीओ के साथ आप कर सकते हैं:

• डेटा क्रमबद्ध करें (Json)
• परिपत्र संदर्भों से छुटकारा पाएं
• उन गुणों को छोड़ कर नेटवर्क क्षमता को कम करें जिनकी आपको आवश्यकता नहीं है (viewmodelwise)
• ऑब्जेक्टफ्लैटिंग का उपयोग करें

मैं इस साल इसे स्कूल में सीख रहा हूं और यह बहुत उपयोगी उपकरण है।

Answer 9

यदि आप इकाई ढांचे का उपयोग कर रहे हैं, तो DbContext से संपत्ति को हटाने की कोशिश करें जो आपके जटिल मॉडल का उपयोग करता है Entity के रूप में मुझे एक ही समस्या थी जब कई मॉडल को Entity नाम के एक viewmodel में मैप करना

public DbSet<Entity> Entities { get; set; }

DbContext से प्रविष्टि को हटाने से मेरी त्रुटि ठीक हो गई।

Answer 10

यदि आप निष्पादित कर रहे हैं, तो आप क्वेरी के बंद होने के साथ Linq to Entityउपयोग नहीं कर सकतेClassTypenewselectonly anonymous types are allowed (new without type)

मेरी परियोजना के इस स्निपेट को देखें

//...
var dbQuery = context.Set<Letter>()
                .Include(letter => letter.LetterStatus)
                .Select(l => new {Title =l.Title,ID = l.ID, LastModificationDate = l.LastModificationDate, DateCreated = l.DateCreated,LetterStatus = new {ID = l.LetterStatusID.Value,NameInArabic = l.LetterStatus.NameInArabic,NameInEnglish = l.LetterStatus.NameInEnglish} })
                               ^^ without type__________________________________________________________________________________________________________^^ without type

आप new keywordमें सेलेक्ट क्लोजर में भी जोड़ा गया है यहाँ तक कि complex propertiesआपको यह एरर मिलेगी

इतना पर कीवर्ड प्रश्नों ,,removeClassTypes from newLinq to Entity

क्योंकि यह sql स्टेटमेंट में बदल जाएगा और SqlServer पर निष्पादित हो जाएगा

तो मैं बंद करने new with typesपर कब उपयोग कर सकता हूं select?

आप इसका उपयोग कर सकते हैं यदि आप के साथ काम कर रहे हैं LINQ to Object (in memory collection)

//opecations in tempList , LINQ to Entities; so we can not use class types in select only anonymous types are allowed
var tempList = dbQuery.Skip(10).Take(10).ToList();// this is list of <anonymous type> so we have to convert it so list of <letter>

//opecations in list , LINQ to Object; so we can use class types in select
list = tempList.Select(l => new Letter{ Title = l.Title, ID = l.ID, LastModificationDate = l.LastModificationDate, DateCreated = l.DateCreated, LetterStatus = new LetterStatus{ ID = l.LetterStatus.ID, NameInArabic = l.LetterStatus.NameInArabic, NameInEnglish = l.LetterStatus.NameInEnglish } }).ToList();
                                ^^^^^^ with type 

मैं ToListक्वेरी पर निष्पादित होने के बाद यह बन गया in memory collection ताकि हम new ClassTypesचयन में उपयोग कर सकें

Comments

सुनिश्चित करें कि आप अनाम प्रकारों का उपयोग कर सकते हैं, लेकिन आप एक अनाम सदस्य सेट करने के लिए भी LINQ क्वेरी के भीतर एक इकाई नहीं बना सकते, क्योंकि LINQ-to-Entities अभी भी एक ही अपवाद फेंकता है।

— सनकैट २२

Answer 11

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

एक सरल तरीका यह कर रहा है:

IEnumerable<object> list = dataContext.Table.Select(e => new { MyRequiredField = e.MyRequiredField}).AsEnumerable();

Answer 12

यह आपको उत्पाद पर वापस जाने की अनुमति नहीं देगा क्योंकि वह आपकी तालिका है जिसे आप क्वेरी कर रहे हैं। आपको एक अनाम फ़ंक्शन की आवश्यकता है, फिर आप इसे एक ViewModel में जोड़ सकते हैं, और प्रत्येक ViewModel को एक में जोड़ सकते हैं List<MyViewModel>और इन्हें वापस कर सकते हैं। यह एक मामूली विषयांतर है, लेकिन मैं अशक्त तारीखों को संभालने के बारे में कैविट्स को शामिल करता हूं, क्योंकि इन मामलों से निपटने के लिए आपको दर्द होता है, बस आपके पास कोई भी हो। इस तरह मैंने इसे संभाला।

उम्मीद है आपके पास ProductViewModel:

public class ProductViewModel
{
    [Key]
    public string ID { get; set; }
    public string Name { get; set; }
}

मेरे पास निर्भरता इंजेक्शन / रिपॉजिटरी ढांचा है जहां मैं अपने डेटा को हथियाने के लिए एक फ़ंक्शन कहता हूं। उदाहरण के रूप में अपनी पोस्ट का उपयोग करते हुए, आपके नियंत्रक फ़ंक्शन कॉल में, यह इस तरह दिखाई देगा:

int categoryID = 1;
var prods = repository.GetProducts(categoryID);

रिपॉजिटरी क्लास में:

public IEnumerable<ProductViewModel> GetProducts(int categoryID)
{
   List<ProductViewModel> lstPVM = new List<ProductViewModel>();

   var anonymousObjResult = from p in db.Products
                            where p.CategoryID == categoryID 
                            select new
                            {
                                CatID = p.CategoryID,
                                Name = p.Name
                            };

        // NOTE: If you have any dates that are nullable and null, you'll need to
        // take care of that:  ClosedDate = (DateTime?)p.ClosedDate ?? DateTime.Now

        // If you want a particular date, you have to define a DateTime variable,
        // assign your value to it, then replace DateTime.Now with that variable. You
        // cannot call a DateTime.Parse there, unfortunately. 
        // Using 
        //    new Date("1","1","1800"); 
        // works, though. (I add a particular date so I can edit it out later.)

        // I do this foreach below so I can return a List<ProductViewModel>. 
        // You could do: return anonymousObjResult.ToList(); here
        // but it's not as clean and is an anonymous type instead of defined
        // by a ViewModel where you can control the individual field types

        foreach (var a in anonymousObjResult)
        {                
            ProductViewModel pvm = new ProductViewModel();
            pvm.ID = a.CatID;  
            pvm.Name = a.Name;
            lstPVM.Add(rvm);
        }

        // Obviously you will just have ONE item there, but I built it 
        // like this so you could bring back the whole table, if you wanted
        // to remove your Where clause, above.

        return lstPVM;
    }

नियंत्रक में वापस, आप करते हैं:

 List<ProductViewModel> lstProd = new List<ProductViewModel>();

 if (prods != null) 
 {
    // For setting the dates back to nulls, I'm looking for this value:
    // DateTime stdDate = DateTime.Parse("01/01/1800");

    foreach (var a in prods)
    {
        ProductViewModel o_prod = new ReportViewModel();
        o_prod.ID = a.ID;
        o_prod.Name = a.Name;
       // o_prod.ClosedDate = a.ClosedDate == stdDate ? null : a.ClosedDate;
        lstProd.Add(o_prod);
    }
}
return View(lstProd);  // use this in your View as:   @model IEnumerable<ProductViewModel>

Answer 13

केवल आसन जोड़ने योग्य ():

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products.AsEnumerable()
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}

Comments

ऐसा कभी नहीं करे! यह DB से सभी डेटा प्राप्त करेगा और फिर चयन करेगा।

— Gh61

यही कारण है कि कुछ कंपनियों में Linq का उपयोग करने के लिए मना किया जाता है।

— हांक नोव

Answer 14

आप इस तरह अपने संग्रह में AsEnumerable जोड़ सकते हैं:

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products.AsEnumerable()
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}

Comments

क्यों यह एक बुरा जवाब है, हालांकि यह काम करता है ... .Enumerable संस्थाओं को linq समाप्त होता है। जहाँ क्लॉज़ और बाकी सब चीज़ों को लाइनिक से लेकर एंटिटीज़ के बाहर संभाला जाता है। यानी हर उत्पाद को तब प्राप्त किया जाता है जब उसे वस्तुओं के लिए लाइनक द्वारा फ़िल्टर किया जाता है। इसके अलावा यह बहुत ज्यादा है। ऊपर दिए गए उत्तर के रूप में। stackoverflow.com/questions/5311034/…

— KenF

इसके साथ समस्या यह है कि ... से केवल एक चयन * किया जाता है, नए उत्पाद का चयन नहीं किया जाता है {Name = p.Name}, क्योंकि आपको एक चक्रीय संदर्भ भी मिलेगा। और आप सिर्फ नाम चाहते हैं।

— स्टर्लिंग डियाज़