LINQ-to-Entities में "मानों में कहां" कैसे करें 3.5

Question

क्या कोई जानता है कि LINQ-to-Entities का उपयोग करके "मूल्यों में कहां" प्रकार की स्थिति को कैसे लागू किया जाए? मैं निम्नलिखित की कोशिश की है, लेकिन यह काम नहीं करता है:

var values = new[] { "String1", "String2" }; // some string values 

var foo = model.entitySet.Where(e => values.Contains(e.Name)); 

मेरा मानना ​​है कि यह हालांकि करने के लिए एसक्यूएल LINQ में काम करता है? कोई विचार?

Answer 1

यह कुछ हद तक शर्म की बात है कि Contains is not supported in Linq to Entities।

आईएन और जॉइन एक ही ऑपरेटर नहीं हैं (फ़िल्टरिंग द्वारा क्वेरी की कार्डिनालिटी कभी नहीं बदलती है)।

Answer 2

हाँ, यह एसक्यूएल में अनुवाद करता है, यह इस तरह बयान में एक मानक उत्पन्न करता है:।

का चयन करें [t0] [col1] [तालिका] [t0] कहां [col1] में ('मान 1 ',' मान 2 ')

Answer 3

जहां विधि alway काम नहीं करता है

var results = from p in db.Products 

      where p.Name == nameTextBox.Text 

      select p; 

Answer 4

अद्यतन का उपयोग करना: पता चला कि इसे कैसे किया। और ईएफ डेटाबेस पर उपयुक्त एसक्यूएल उत्पन्न करेगा। मुझे यकीन है कि अगर यह केवल EF4 के लिए है नहीं कर रहा हूँ, लेकिन मैं इकाई की रूपरेखा से 4.0 व्यंजनों

---

var listOfIds=GetAListOfIds(); 
var context=CreateEntityFrameworkObjectContext(); 
var results = from item in context.Items 
       where listOfIds.Contains(item.Category.Id) 
       select item; 
//results contains the items with matching category Ids 

इस क्वेरी सर्वर साइड पर खंड में सही उत्पन्न टिप मिल गया। मैंने इसे ईएफ 3.5 के साथ परीक्षण नहीं किया है लेकिन यह ईएफ 4 के साथ काम करता है।

एनबी: खंड में पारित मान पैरामीटर नहीं हैं इसलिए सुनिश्चित करें कि आप अपने इनपुट को मान्य करते हैं।

Answer 5

इस समय ईएफ में समर्थित नहीं है।

Answer 6

FYI करें:

आप ESql उपयोग कर रहे हैं आप ऑपरेशन में उपयोग करने के लिए सक्षम हैं। मैं मेरे साथ 2008 नहीं है, लेकिन कोड निम्नलिखित की तरह कुछ किया जाना चाहिए:

var ids = "12, 34, 35"; 
using (context = new Entites()) 
{ 
    var selectedProducts = context.CreateQuery<Products>(
     String.Format("select value p from [Entities].Products as p 
         where p.productId in {{{0}}}", ids)).ToList(); 
    ... 
} 

Answer 7

मामलों के लिए जब आप एक्सप्रेशन का उपयोग करना है जब आपके डेटा की क्वेरी, तो आपको निम्न विस्तार विधि (http://social.msdn.microsoft.com/forums/en-US/adodotnetentityframework/thread/095745fe-dcf0-4142-b684-b7e4a1ab59f0/ के बाद अनुकूलित उपयोग कर सकते हैं चाहता हूँ):

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Data.Objects; 

namespace Sample { 
    public static class Extensions { 
     public static IQueryable<T> ExtWhereIn<T, TValue>(this ObjectQuery<T> query, 
        Expression<Func<T, TValue>> valueSelector, 
        IEnumerable<TValue> values) { 
      return query.Where(BuildContainsExpression<T, TValue>(valueSelector, values)); 
     } 
     public static IQueryable<T> ExtWhereIn<T, TValue>(this IQueryable<T> query, 
      Expression<Func<T, TValue>> valueSelector, 
      IEnumerable<TValue> values) { 
      return query.Where(BuildContainsExpression<T, TValue>(valueSelector, values)); 
     } 
     private static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(
       Expression<Func<TElement, TValue>> valueSelector, IEnumerable<TValue> values) { 
      if (null == valueSelector) { throw new ArgumentNullException("valueSelector"); } 
      if (null == values) { throw new ArgumentNullException("values"); } 
      ParameterExpression p = valueSelector.Parameters.Single(); 
      // p => valueSelector(p) == values[0] || valueSelector(p) == ... 
      if (!values.Any()) { 
       return e => false; 
      } 
      var equals = values.Select(value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue)))); 
      var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal)); 
      return Expression.Lambda<Func<TElement, bool>>(body, p); 
     } 
    } 
    class Program { 
     static void Main(string[] args) { 
      List<int> fullList = new List<int>(); 
      for (int i = 0; i < 20; i++) { 
       fullList.Add(i); 
      } 

      List<int> filter = new List<int>(); 
      filter.Add(2); 
      filter.Add(5); 
      filter.Add(10); 

      List<int> results = fullList.AsQueryable().ExtWhereIn<int, int>(item => item, filter).ToList(); 
      foreach (int result in results) { 
       Console.WriteLine(result); 
      } 
     } 
    }  
} 

एक्सटेंशन का उपयोग करना) वास्तव में आसान है (जैसा कि आप नमूने में देख सकते हैं।

class Product { 
    public int Id { get; set; } 
    /// ... other properties 
} 


List<Product> GetProducts(List<int> productIds) {  
    using (MyEntities context = new MyEntities()) { 
     return context.Products.ExtWhereIn<Product, int>(product => product.Id, productIds).ToList(); 
    } 
}