লিনকুতে অপারেটর পছন্দ করুন

Question 1

এসকিউএল LIKEঅপারেটরের অনুরূপ সি # লিনকিউ এক্সপ্রেশনটিতে স্ট্রিংগুলির তুলনা করার কোনও উপায় আছে কি ?

ধরুন আমার কাছে স্ট্রিং লিস্ট আছে। এই তালিকায় আমি একটি স্ট্রিং অনুসন্ধান করতে চাই। এসকিউএল-তে আমি লিখতে পারি:

SELECT * FROM DischargePort WHERE PortName LIKE '%BALTIMORE%'

উপরের পরিবর্তে, ক্যোয়ারী একটি লিনাক সিনট্যাক্স চায়।

using System.Text.RegularExpressions;
…

var regex = new Regex(sDischargePort, RegexOptions.IgnoreCase);
var sPortCode = Database.DischargePorts
                .Where(p => regex.IsMatch(p.PortName))
                .Single().PortCode;

আমার উপরের লিনকিউ সিনট্যাক্সটি কাজ করে না। আমার কী ভুল হয়েছে?

Question 2

সাধারণত আপনি String.StartsWith/ EndsWith/ ব্যবহার করেন Contains। উদাহরণ স্বরূপ:

var portCode = Database.DischargePorts
                       .Where(p => p.PortName.Contains("BALTIMORE"))
                       .Single()
                       .PortCode;

আমি জানি না যদিও লিনকিউ এর মাধ্যমে এসকিউএল এর মাধ্যমে নিয়মিত নিয়মিত প্রকাশ করার কোনও উপায় আছে কিনা। (মনে রাখবেন যে আপনি যে সরবরাহকারীর ব্যবহার করছেন তার উপর এটি নির্ভর করে - এটি লিনকিউতে অবজেক্টে ভাল হবে; সরবরাহকারী কলটিকে তার স্থানীয় কোয়েরি ফর্ম্যাটে যেমন, এসকিউএল রূপান্তর করতে পারে কিনা তা বিষয়))

সম্পাদনা: বিটকফু যেমন বলেছে, Singleআপনি যখন ঠিক একটি ফলাফল আশা করেন তখন ব্যবহার করা উচিত - যখন এটির ক্ষেত্রে সমস্যা না হয়। এর বিকল্প SingleOrDefault, FirstOrDefaultবা Firstতার উপর নির্ভর করে ব্যবহার করা উচিত ঠিক যা প্রত্যাশা করছে।

Question 3

রেজেক্স? না তবে সেই প্রশ্নের জন্য আপনি কেবল ব্যবহার করতে পারেন:

 string filter = "BALTIMORE";
 (blah) .Where(row => row.PortName.Contains(filter)) (blah)

আপনি যদি সত্যিই এসকিউএল চান LIKE, আপনি ব্যবহার করতে পারেন System.Data.Linq.SqlClient.SqlMethods.Like(...), যা LIKEএসকিউএল সার্ভারে লিনিক-টু-এসকিউএল মানচিত্র করে ।

Question 4

ভাল ... কখনও কখনও এটি ব্যবহার করতে অস্বস্তিকর হতে পারে Contains, StartsWithবা EndsWithবিশেষত যখন অনুসন্ধানের মান নির্ধারণ করে LIKEযেমন বিকাশকারী StartsWithফাংশনটি ব্যবহার করার জন্য বিকাশকারীর কাছ থেকে 'মান%' পাস করা হয় । সুতরাং আমি IQueryableঅবজেক্টের জন্য এক্সটেনশন লিখতে সিদ্ধান্ত নিয়েছি ।

ব্যবহার

// numbers: 11-000-00, 00-111-00, 00-000-11

var data1 = parts.Like(p => p.Number, "%11%");
// result: 11-000-00, 00-111-00, 00-000-11

var data2 = parts.Like(p => p.Number, "11%");
// result: 11-000-00

var data3 = parts.Like(p => p.Number, "%11");
// result: 00-000-11

কোড

public static class LinqEx
{
    private static readonly MethodInfo ContainsMethod = typeof(string).GetMethod("Contains");
    private static readonly MethodInfo StartsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
    private static readonly MethodInfo EndsWithMethod = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });

    public static Expression<Func<TSource, bool>> LikeExpression<TSource, TMember>(Expression<Func<TSource, TMember>> property, string value)
    {
        var param = Expression.Parameter(typeof(TSource), "t");
        var propertyInfo = GetPropertyInfo(property);
        var member = Expression.Property(param, propertyInfo.Name);

        var startWith = value.StartsWith("%");
        var endsWith = value.EndsWith("%");

        if (startWith)
            value = value.Remove(0, 1);

        if (endsWith)
            value = value.Remove(value.Length - 1, 1);

        var constant = Expression.Constant(value);
        Expression exp;

        if (endsWith && startWith)
        {
            exp = Expression.Call(member, ContainsMethod, constant);
        }
        else if (startWith) 
        {
            exp = Expression.Call(member, EndsWithMethod, constant);
        }
        else if (endsWith)
        {
            exp = Expression.Call(member, StartsWithMethod, constant);
        }
        else
        {
            exp = Expression.Equal(member, constant);
        }

        return Expression.Lambda<Func<TSource, bool>>(exp, param);
    }

    public static IQueryable<TSource> Like<TSource, TMember>(this IQueryable<TSource> source, Expression<Func<TSource, TMember>> parameter, string value)
    {
        return source.Where(LikeExpression(parameter, value));
    }

    private static PropertyInfo GetPropertyInfo(Expression expression)
    {
        var lambda = expression as LambdaExpression;
        if (lambda == null)
            throw new ArgumentNullException("expression");

        MemberExpression memberExpr = null;

        switch (lambda.Body.NodeType)
        {
            case ExpressionType.Convert:
                memberExpr = ((UnaryExpression)lambda.Body).Operand as MemberExpression;
                break;
            case ExpressionType.MemberAccess:
                memberExpr = lambda.Body as MemberExpression;
                break;
        }

        if (memberExpr == null)
            throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");


        var output = memberExpr.Member as PropertyInfo;

        if (output == null)
            throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");

        return output;
    }
}

Question 5

নেটিভ লিনকুইতে আপনি Contains/StartsWith/EndsWithরেজিপ্যাক্সের সংমিশ্রণ ব্যবহার করতে পারেন ।

LINQ2SQL- এ ব্যবহার পদ্ধতি SqlMethods.Like()

    from i in db.myTable
    where SqlMethods.Like(i.field, "tra%ata")
    select i

এই বৈশিষ্ট্যটি ব্যবহার করতে એસেম্বলি: System.Data.Linq (System.Data.Linq.dll এ) যুক্ত করুন।

Question 6

জন স্কিটি এবং মার্ক গ্র্যাভেল ইতিমধ্যে উল্লিখিত হিসাবে, আপনি সহজভাবে একটি শর্ত থাকে take তবে আপনার মত ক্যোয়ারির ক্ষেত্রে, একটি একক () বিবৃতি নেওয়া খুব বিপজ্জনক, কারণ এর দ্বারা বোঝা যায় যে আপনি কেবল 1 টি ফলাফল পেয়েছেন। আরও ফলাফলের ক্ষেত্রে, আপনি একটি দুর্দান্ত ব্যতিক্রম পাবেন :)

সুতরাং আমি সিঙ্গল () এর পরিবর্তে ফার্স্টআরডিফল্ট () ব্যবহার করতে পছন্দ করব:

var first = Database.DischargePorts.FirstOrDefault(p => p.PortName.Contains("BALTIMORE"));
var portcode = first != null ? first.PortCode : string.Empty;

Question 7

এই হিসাবে একটি সহজ

string[] users = new string[] {"Paul","Steve","Annick","Yannick"};    
var result = from u in users where u.Contains("nn") select u;

ফলাফল -> আনিক, ইয়ানিক

Question 8

আদর্শভাবে আপনার ব্যবহার করা উচিত StartWithবা EndWith।

এখানে একটি উদাহরণ:

DataContext  dc = new DCGeneral();
List<Person> lstPerson= dc.GetTable<Person>().StartWith(c=> c.strNombre).ToList();

return lstPerson;

Question 9

আপনি একা পদ্ধতিতে একটি প্রিকেট দিয়ে কল করতে পারেন:

var portCode = Database.DischargePorts
                   .Single(p => p.PortName.Contains("BALTIMORE"))
                   .PortCode;

Question 10

  .Where(e => e.Value.StartsWith("BALTIMORE"))

এটি এসকিউএল এর "লাইক" এর মতো কাজ করে ...

Question 11

List<Categories> categoriess;
        private void Buscar()
        {
            try
            {
                categoriess = Contexto.Categories.ToList();
                categoriess = categoriess.Where(n => n.CategoryID >= Convert.ToInt32(txtCatID.Text) && n.CategoryID <= Convert.ToInt32(txtCatID1.Text) && (n.CategoryName.Contains(txtCatName.Text)) ).ToList();

Question 12

   public static class StringEx
    {
        public static bool Contains(this String str, string[] Arr, StringComparison comp)
        {
            if (Arr != null)
            {
                foreach (string s in Arr)
                {
                    if (str.IndexOf(s, comp)>=0)
                    { return true; }
                }
            }

            return false;
        }

        public static bool Contains(this String str,string[] Arr)
        {
            if (Arr != null)
            {
                foreach (string s in Arr)
                {
                    if (str.Contains(s))
                    { return true; }
                }
            }

            return false;
        }
    }


var portCode = Database.DischargePorts
                   .Single(p => p.PortName.Contains( new string[] {"BALTIMORE"},  StringComparison.CurrentCultureIgnoreCase) ))
                   .PortCode;

Question 13

স্ট্রিং অবজেক্ট এক্সটেনশন পদ্ধতিগুলিতে কেবল যুক্ত করুন।

public static class StringEx
{
    public static bool Contains(this String str, string[] Arr, StringComparison comp)
    {
        if (Arr != null)
        {
            foreach (string s in Arr)
            {
                if (str.IndexOf(s, comp)>=0)
                { return true; }
            }
        }

        return false;
    }

    public static bool Contains(this String str,string[] Arr)
    {
        if (Arr != null)
        {
            foreach (string s in Arr)
            {
                if (str.Contains(s))
                { return true; }
            }
        }

        return false;
    }
}

ব্যবহার:

use namespase that contains this class;

var sPortCode = Database.DischargePorts
            .Where(p => p.PortName.Contains(new string [] {"BALTIMORE"},  StringComparison.CurrentCultureIgnoreCase) )
            .Single().PortCode;

Question 14

@ অ্যাডোব্রিজকের দুর্দান্ত কাস্টম LIKEফাংশন ছিল - আমি এর IEnumerableসংস্করণটি কেবল ভাগ করে নিতে চেয়েছিলাম ।

public static class LinqEx
{
    private static readonly MethodInfo ContainsMethod = typeof(string).GetMethod("Contains");
    private static readonly MethodInfo StartsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
    private static readonly MethodInfo EndsWithMethod = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });

    private static Func<TSource, bool> LikeExpression<TSource, TMember>(Expression<Func<TSource, TMember>> property, string value)
    {
        var param = Expression.Parameter(typeof(TSource), "t");
        var propertyInfo = GetPropertyInfo(property);
        var member = Expression.Property(param, propertyInfo.Name);

        var startWith = value.StartsWith("%");
        var endsWith = value.EndsWith("%");

        if (startWith)
            value = value.Remove(0, 1);

        if (endsWith)
            value = value.Remove(value.Length - 1, 1);

        var constant = Expression.Constant(value);
        Expression exp;

        if (endsWith && startWith)
        {
            exp = Expression.Call(member, ContainsMethod, constant);
        }
        else if (startWith)
        {
            exp = Expression.Call(member, EndsWithMethod, constant);
        }
        else if (endsWith)
        {
            exp = Expression.Call(member, StartsWithMethod, constant);
        }
        else
        {
            exp = Expression.Equal(member, constant);
        }

        return Expression.Lambda<Func<TSource, bool>>(exp, param).Compile();
    }

    public static IEnumerable<TSource> Like<TSource, TMember>(this IEnumerable<TSource> source, Expression<Func<TSource, TMember>> parameter, string value)
    {
        return source.Where(LikeExpression(parameter, value));
    }


    private static PropertyInfo GetPropertyInfo(Expression expression)
    {
        var lambda = expression as LambdaExpression;
        if (lambda == null)
            throw new ArgumentNullException("expression");

        MemberExpression memberExpr = null;

        switch (lambda.Body.NodeType)
        {
            case ExpressionType.Convert:
                memberExpr = ((UnaryExpression)lambda.Body).Operand as MemberExpression;
                break;
            case ExpressionType.MemberAccess:
                memberExpr = lambda.Body as MemberExpression;
                break;
        }

        if (memberExpr == null)
            throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");


        var output = memberExpr.Member as PropertyInfo;

        if (output == null)
            throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");

        return output;
    }
}

Question 15

এক্সটেনশন লিনক / এসকিউএল এর মতো

লাইক এক্সটেনশন ক্লাস

নেট 5 তে পরীক্ষিত

 public static class LikeExtension {

    private static string ColumnDataBase<TEntity, TKey>(IModel model, Expression<Func<TEntity, TKey>> predicate) where TEntity : class {

        ITable table = model
            .GetRelationalModel()
            .Tables
            .First(f => f
                .EntityTypeMappings
                .First()
                .EntityType == model
                .FindEntityType(predicate
                    .Parameters
                    .First()
                .Type
            ));

        string column = (predicate.Body as MemberExpression).Member.Name;
        string columnDataBase = table.Columns.First(f => f.PropertyMappings.Count(f2 => f2.Property.Name == column) > 0).Name;

        return columnDataBase;

    }

    public static IQueryable<TEntity> Like<TEntity, TKey>(this DbContext context, Expression<Func<TEntity, TKey>> predicate, string text) where TEntity : class {

        string columnDataBase = ColumnDataBase(context.Model, predicate);
        return context.Set<TEntity>().FromSqlRaw(context.Set<TEntity>().ToQueryString() + " WHERE [" + columnDataBase + "] LIKE {0}", text);

    }

    public static async Task<IEnumerable<TEntity>> LikeAsync<TEntity, TKey>(this DbContext context, Expression<Func<TEntity, TKey>> predicate, string text, CancellationToken cancellationToken) where TEntity : class {

        string columnDataBase = ColumnDataBase(context.Model, predicate);
        return await context.Set<TEntity>().FromSqlRaw(context.Set<TEntity>().ToQueryString() + " WHERE [" + columnDataBase + "] LIKE {0}", text).ToListAsync(cancellationToken);

    }

    public static async Task<IEnumerable<TEntity>> LikeAsync<TEntity, TKey>(this IQueryable<TEntity> query, Expression<Func<TEntity, TKey>> predicate, string text, CancellationToken cancellationToken) where TEntity : class {

        DbSet<TEntity> entities = query as DbSet<TEntity>;
        string columnDataBase = ColumnDataBase(entities.EntityType.Model, predicate);
        return await entities.FromSqlRaw(query.ToQueryString() + " WHERE [" + columnDataBase + "] LIKE {0}", text).ToListAsync(cancellationToken);

    }

    public static IQueryable<TEntity> Like<TEntity, TKey>(this IQueryable<TEntity> query, Expression<Func<TEntity, TKey>> predicate, string text) where TEntity : class {

        DbSet<TEntity> entities = query as DbSet<TEntity>;
        string columnDataBase = ColumnDataBase(entities.EntityType.Model, predicate);
        return entities.FromSqlRaw(query.ToQueryString() + " WHERE [" + columnDataBase + "] LIKE {0}", text);

    }

}

ভান্ডার

    public async Task<IEnumerable<TEntity>> LikeAsync<TKey>(Expression<Func<TEntity, TKey>> predicate, string text, CancellationToken cancellationToken) {

        return await context.LikeAsync(predicate, text, cancellationToken);

    }

    public IQueryable<TEntity> Like<TKey>(Expression<Func<TEntity, TKey>> predicate, string text) {

        return context.Like(predicate, text);

    }

ব্যবহার

 IQueryable<CountryEntity> result = countryRepository
     .Like(k => k.Name, "%Bra[sz]il%") /*Use Sync*/
     .Where(w => w.DateRegister < DateTime.Now) /*Example*/
     .Take(10); /*Example*/

বা

 IEnumerable<CountryEntity> result = await countryRepository
     .LikeAsync(k => k.Name, "%Bra[sz]il%", cancellationToken); /*Use Async*/

বা

 IQueryable<CountryEntity> result = context.Countries
     .Like(k => k.Name, "%Bra[sz]il%")
     .Where(w => w.Name != null); /*Example*/

বা

 List<CountryEntity> result2 = await context.Countries
     .Like(k => k.Name, "%Bra[sz]il%")
     .Where(w => w.Name != null) /*Example*/
     .ToListAsync(); /*Use Async*/

বা

 IEnumerable<CountryEntity> result3 = await context.Countries
     .Where(w => w.Name != null)
     .LikeAsync(k => k.Name, "%Bra[sz]il%", cancellationToken); /*Use Async*/

Question 16

আপনি। নেট 5 এ পরীক্ষা করা EF ফাংশনটিও ব্যবহার করতে পারেন

public async Task<IEnumerable<District>> SearchDistrict(string query, int stateId)
        {
            return await _dbContext
                .Districts
                .Include(s => s.State)
                .Where(s => s.StateId == stateId && EF.Functions.Like(s.Name, "$%{query}%"))
                .AsNoTracking()
                .ToListAsync();
        }