हम स्ट्रिंग क्षेत्रों के साथ हमारी संस्थाओं के लिए इकाई ढांचे में "LIKE" ऑपरेटर को लागू करने की कोशिश कर रहे हैं, लेकिन यह समर्थित नहीं है। क्या किसी और ने ऐसा कुछ करने की कोशिश की है?
यह ब्लॉग पोस्ट उस समस्या को सारांशित करता है जो हम कर रहे हैं। हम उपयोग कर सकते हैं, लेकिन यह केवल LIKE के लिए सबसे तुच्छ मामले से मेल खाता है। संयोजन में, startswith, Endwith, और indexof शामिल हैं, जो हमें वहां मिलता है, लेकिन मानक वाइल्डकार्ड और Linq से Entities कोड के बीच अनुवाद की आवश्यकता होती है।
जवाबों:
यह अब एक पुरानी पोस्ट है, लेकिन किसी को भी उत्तर की तलाश में, इस लिंक की मदद करनी चाहिए। इस उत्तर पर जाएं यदि आप पहले से ही EF 6.2.x का उपयोग कर रहे हैं। करने के लिए इस सवाल का जवाब आप एफई कोर 2.x उपयोग कर रहे हैं
लघु संस्करण:
SqlFunctions.PatIndex विधि - एक निर्दिष्ट अभिव्यक्ति में एक पैटर्न की पहली घटना की प्रारंभिक स्थिति लौटाता है, या यदि सभी मान्य पाठ और वर्ण डेटा प्रकारों पर पैटर्न नहीं मिला है, तो शून्य
नामस्थान: System.Data.Objects.SqlClient विधानसभा: System.Data.Entity (System.Data.Entity.dll में)
इस फोरम थ्रेड में थोड़ा सा स्पष्टीकरण भी दिखाई देता है ।
मैं वास्तव में EF के बारे में कुछ नहीं जानता, लेकिन LINQ से SQL में आप आमतौर पर String.Containes का उपयोग करके एक LIKE क्लॉज व्यक्त करते हैं:
where entity.Name.Contains("xyz")
में अनुवाद करता है
WHERE Name LIKE '%xyz%'
(प्रयोग StartsWithऔर EndsWithअन्य व्यवहार के लिए।)
मुझे पूरी तरह से यकीन नहीं है कि यह मददगार है, क्योंकि मुझे समझ में नहीं आता है कि जब आप कहते हैं कि आप LIKE को लागू करने की कोशिश कर रहे हैं । अगर मैं पूरी तरह से गलत समझा, मुझे पता है और मैं इस जवाब को हटा दूँगा :)
मुझे भी यही समस्या थी।
अभी के लिए, मैंने http://www.codeproject.com/Articles/11556/Converting-Wildcards-to-Regexes?msg=1423024_xx1423024xxxx पर आधारित क्लाइंट-साइड वाइल्डकार्ड / रेगेक्स फ़िल्टरिंग के साथ समझौता किया है - यह सरल है और यह काम करता है। अपेक्षित होना।
मुझे इस विषय पर एक और चर्चा मिली है: http://forums.asp.net/t/1654093.aspx/2/10
यह पोस्ट आशाजनक लगता है यदि आप इकाई फ्रेमवर्क का उपयोग करते हैं> = 4.0:
SqlFunctions.PatIndex का उपयोग करें:
http://msdn.microsoft.com/en-us/library/system.data.objects.sqlclient.sqlfunctions.patindex.aspx
इस कदर:
var q = EFContext.Products.Where(x => SqlFunctions.PatIndex("%CD%BLUE%", x.ProductName) > 0);
नोट: यह समाधान केवल SQL- सर्वर के लिए है, क्योंकि यह गैर-मानक PATINDEX फ़ंक्शन का उपयोग करता है।
अपडेट: ईएफ 6.2 में एक ऑपरेटर की तरह है
Where(obj => DbFunctions.Like(obj.Column , "%expression%")
Where(obj => DbFunctions.Like(obj.Column , "%expression%"):?
वहाँ है LIKE ऑपरेटर जोड़ा गया है Entity Framework Core 2.0:
var query = from e in _context.Employees
where EF.Functions.Like(e.Title, "%developer%")
select e;
तुलना करने के ... where e.Title.Contains("developer") ...लिए वास्तव में इसका अनुवाद करने के SQL LIKEबजाय CHARINDEXहम Containsविधि के लिए देखते हैं ।
यह डॉक्यूमेंट में एंटिटी एसक्यूएल के हिस्से के रूप में विशेष रूप से उल्लेखित है। क्या आपको कोई त्रुटि संदेश मिल रहा है?
// LIKE and ESCAPE
// If an AdventureWorksEntities.Product contained a Name
// with the value 'Down_Tube', the following query would find that
// value.
Select value P.Name FROM AdventureWorksEntities.Product
as P where P.Name LIKE 'DownA_%' ESCAPE 'A'
// LIKE
Select value P.Name FROM AdventureWorksEntities.Product
as P where P.Name like 'BB%'
यदि आप MS Sql का उपयोग कर रहे हैं, तो मैंने वाइल्डकार्ड खोज के लिए% वर्ण का समर्थन करने के लिए 2 विस्तार विधियाँ लिखी हैं। (LinKKit की आवश्यकता है)
public static class ExpressionExtension
{
public static Expression<Func<T, bool>> Like<T>(Expression<Func<T, string>> expr, string likeValue)
{
var paramExpr = expr.Parameters.First();
var memExpr = expr.Body;
if (likeValue == null || likeValue.Contains('%') != true)
{
Expression<Func<string>> valExpr = () => likeValue;
var eqExpr = Expression.Equal(memExpr, valExpr.Body);
return Expression.Lambda<Func<T, bool>>(eqExpr, paramExpr);
}
if (likeValue.Replace("%", string.Empty).Length == 0)
{
return PredicateBuilder.True<T>();
}
likeValue = Regex.Replace(likeValue, "%+", "%");
if (likeValue.Length > 2 && likeValue.Substring(1, likeValue.Length - 2).Contains('%'))
{
likeValue = likeValue.Replace("[", "[[]").Replace("_", "[_]");
Expression<Func<string>> valExpr = () => likeValue;
var patExpr = Expression.Call(typeof(SqlFunctions).GetMethod("PatIndex",
new[] { typeof(string), typeof(string) }), valExpr.Body, memExpr);
var neExpr = Expression.NotEqual(patExpr, Expression.Convert(Expression.Constant(0), typeof(int?)));
return Expression.Lambda<Func<T, bool>>(neExpr, paramExpr);
}
if (likeValue.StartsWith("%"))
{
if (likeValue.EndsWith("%") == true)
{
likeValue = likeValue.Substring(1, likeValue.Length - 2);
Expression<Func<string>> valExpr = () => likeValue;
var containsExpr = Expression.Call(memExpr, typeof(String).GetMethod("Contains",
new[] { typeof(string) }), valExpr.Body);
return Expression.Lambda<Func<T, bool>>(containsExpr, paramExpr);
}
else
{
likeValue = likeValue.Substring(1);
Expression<Func<string>> valExpr = () => likeValue;
var endsExpr = Expression.Call(memExpr, typeof(String).GetMethod("EndsWith",
new[] { typeof(string) }), valExpr.Body);
return Expression.Lambda<Func<T, bool>>(endsExpr, paramExpr);
}
}
else
{
likeValue = likeValue.Remove(likeValue.Length - 1);
Expression<Func<string>> valExpr = () => likeValue;
var startsExpr = Expression.Call(memExpr, typeof(String).GetMethod("StartsWith",
new[] { typeof(string) }), valExpr.Body);
return Expression.Lambda<Func<T, bool>>(startsExpr, paramExpr);
}
}
public static Expression<Func<T, bool>> AndLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
{
var andPredicate = Like(expr, likeValue);
if (andPredicate != null)
{
predicate = predicate.And(andPredicate.Expand());
}
return predicate;
}
public static Expression<Func<T, bool>> OrLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
{
var orPredicate = Like(expr, likeValue);
if (orPredicate != null)
{
predicate = predicate.Or(orPredicate.Expand());
}
return predicate;
}
}
प्रयोग
var orPredicate = PredicateBuilder.False<People>();
orPredicate = orPredicate.OrLike(per => per.Name, "He%llo%");
orPredicate = orPredicate.OrLike(per => per.Name, "%Hi%");
var predicate = PredicateBuilder.True<People>();
predicate = predicate.And(orPredicate.Expand());
predicate = predicate.AndLike(per => per.Status, "%Active");
var list = dbContext.Set<People>().Where(predicate.Expand()).ToList();
एफई 6 में और इसका अनुवाद करना चाहिए
....
from People per
where (
patindex(@p__linq__0, per.Name) <> 0
or per.Name like @p__linq__1 escape '~'
) and per.Status like @p__linq__2 escape '~'
', @ p__linq__0 ='% He% llo% ', @ p__linq__1 ='% Hi% ', @ p__linq_2 ='% Active '
EfCore के लिए यहाँ LIKE एक्सप्रेशन बनाने के लिए एक नमूना है
protected override Expression<Func<YourEntiry, bool>> BuildLikeExpression(string searchText)
{
var likeSearch = $"%{searchText}%";
return t => EF.Functions.Like(t.Code, likeSearch)
|| EF.Functions.Like(t.FirstName, likeSearch)
|| EF.Functions.Like(t.LastName, likeSearch);
}
//Calling method
var query = dbContext.Set<YourEntity>().Where(BuildLikeExpression("Text"));
आप लिंक की तरह एक वास्तविक का उपयोग कर सकते हैं काफी आसानी से
जोड़ना
<Function Name="String_Like" ReturnType="Edm.Boolean">
<Parameter Name="searchingIn" Type="Edm.String" />
<Parameter Name="lookingFor" Type="Edm.String" />
<DefiningExpression>
searchingIn LIKE lookingFor
</DefiningExpression>
</Function>
इस टैग में अपने EDMX के लिए:
edmx: edmx / edmx: रनटाइम / edmx: ConceptualModels / स्कीमा
नामस्थान भी याद रखें <schema namespace="" />विशेषता
फिर उपरोक्त नामस्थान में एक विस्तार वर्ग जोड़ें:
public static class Extensions
{
[EdmFunction("DocTrails3.Net.Database.Models", "String_Like")]
public static Boolean Like(this String searchingIn, String lookingFor)
{
throw new Exception("Not implemented");
}
}
यह एक्सटेंशन विधि अब EDMX फ़ंक्शन पर मैप करेगी।
अधिक जानकारी यहाँ: http://jendaperl.blogspot.be/2011/02/like-in-linq-to-entities.html