Linq içinde SQL Like% nasıl yapılır?

Linq dönüşmeye çalışıyorum SQL bir yordam var:

SELECT O.Id, O.Name as Organization
FROM Organizations O
JOIN OrganizationsHierarchy OH ON O.Id=OH.OrganizationsId
where OH.Hierarchy like '%/12/%'

En çok ilgilendiğim çizgi:

where OH.Hierarchy like '%/12/%'

/ 1/3/12 / gibi hiyerarşisini depolayan bir sütun var, bu yüzden sadece aramak için% / 12 /% kullanın.

Benim sorum, Linq veya .NET yüzde işaretini kullanmaya eşdeğerdir?

.Where(oh => oh.Hierarchy.Contains("/12/"))

Ayrıca kullanabilir .StartsWith()veya .EndsWith().

Bunu kullan:

from c in dc.Organization
where SqlMethods.Like(c.Hierarchy, "%/12/%")
select *;

Linq-to-SQL * kullandığınızı varsayıyorum (aşağıdaki nota bakın). Öyleyse, SQL LIKE işlecini kullanan SQL oluşturmak için string.Contains, string.StartsWith ve string.EndsWith öğelerini kullanın.

from o in dc.Organization
join oh in dc.OrganizationsHierarchy on o.Id equals oh.OrganizationsId
where oh.Hierarchy.Contains(@"/12/")
select new { o.Id, o.Name }

veya

from o in dc.Organization
where o.OrganizationsHierarchy.Hierarchy.Contains(@"/12/")
select new { o.Id, o.Name }

Not: * = .net 3.5 içinde ADO.Net Entity Framework (EF / L2E) kullanıyorsanız, Linq-to-SQL ile aynı çeviriyi yapmayacağını unutmayın. L2S düzgün bir çeviri yapsa da, L2E v1 (3.5), nerede yan tümcenizde veya birleştirme filtrelerinde başka bir daha iyi ayırıcı yoksa, sorguladığınız tabloda tam tablo taramasını zorlayacak bir t-sql ifadesine dönüşecektir.
Güncelleme: Bu EF / L2E v4 (.net 4.0) ile düzeltildi, bu yüzden L2S gibi bir SQL LIKE üretecek.

VB.NET kullanıyorsanız, yanıt "*" olacaktır. İşte nerede fıkra gibi görünecek ...

Where OH.Hierarchy Like '*/12/*'

Not: "*" Sıfır veya daha fazla karakterle eşleşir. İşte Like işleci için msdn makalesi .

Benim için de çalışıyor

var result = from c in SampleList
where c.LongName.IndexOf(SearchQuery) >= 0
select c;

Bu kodu kullan

try
{
    using (DatosDataContext dtc = new DatosDataContext())
    {
        var query = from pe in dtc.Personal_Hgo
                    where SqlMethods.Like(pe.nombre, "%" + txtNombre.Text + "%")
                    select new
                    {
                        pe.numero
                        ,
                        pe.nombre
                    };
        dgvDatos.DataSource = query.ToList();
    }
}
catch (Exception ex)
{
    string mensaje = ex.Message;
}

.NET core artık EF.Functions.Like

Sayısal dizelerle eşleşmemeniz durumunda, ortak duruma sahip olmak her zaman iyidir:

.Where(oh => oh.Hierarchy.ToUpper().Contains(mySearchString.ToUpper()))

Her zaman bunu yaparım:

from h in OH
where h.Hierarchy.Contains("/12/")
select h

Ben benzer ifade kullanmıyorum biliyorum ama bu arka planda iyi çalışır bu benzer bir ifade ile bir sorguya çevrilmiş olmasıdır.

Bunu dene, bu benim için iyi çalışıyor

from record in context.Organization where record.Hierarchy.Contains(12) select record;

System.Data.Linq.SqlClient.SqlMethods.Like("mystring", "%string")

İçerir Linq kullanılır, Tıpkı Like SQL'de kullanılır.

string _search="/12/";

. . .

.Where(s => s.Hierarchy.Contains(_search))

Linq içinde SQL betiğinizi aşağıdaki gibi yazabilirsiniz:

 var result= Organizations.Join(OrganizationsHierarchy.Where(s=>s.Hierarchy.Contains("/12/")),s=>s.Id,s=>s.OrganizationsId,(org,orgH)=>new {org,orgH});

LINQ bir "SQL Like" yöntemi için bir yol arayan burada benim gibi takla olanlar için, çok iyi çalışan bir şey var.

Ben sütun harmanlamasını değiştirmek için herhangi bir şekilde Veritabanı değiştiremiyorum bir durumda değilim. Bu yüzden LINQ'umda bunu yapmanın bir yolunu bulmalıyım.

Yardımcı yöntemi kullanıyorum SqlFunctions.PatIndex cadı gerçek SQL LIKE operatörüne benzer şekilde kullanıyorum.

Öncelikle, arama değerinde olası tüm aksanları (az önce öğrendiğim bir kelime) numaralandırmam gerekiyor:

déjà     => d[éèêëeÉÈÊËE]j[aàâäAÀÂÄ]
montreal => montr[éèêëeÉÈÊËE][aàâäAÀÂÄ]l
montréal => montr[éèêëeÉÈÊËE][aàâäAÀÂÄ]l

ve sonra örnek için LINQ'da:

var city = "montr[éèêëeÉÈÊËE][aàâäAÀÂÄ]l";
var data = (from loc in _context.Locations
                     where SqlFunctions.PatIndex(city, loc.City) > 0
                     select loc.City).ToList();

Bu yüzden ihtiyaçlarım için bir Yardımcı / Genişletme yöntemi yazdım

   public static class SqlServerHelper
    {

        private static readonly List<KeyValuePair<string, string>> Diacritics = new List<KeyValuePair<string, string>>()
        {
            new KeyValuePair<string, string>("A", "aàâäAÀÂÄ"),
            new KeyValuePair<string, string>("E", "éèêëeÉÈÊËE"),
            new KeyValuePair<string, string>("U", "uûüùUÛÜÙ"),
            new KeyValuePair<string, string>("C", "cçCÇ"),
            new KeyValuePair<string, string>("I", "iîïIÎÏ"),
            new KeyValuePair<string, string>("O", "ôöÔÖ"),
            new KeyValuePair<string, string>("Y", "YŸÝýyÿ")
        };

        public static string EnumarateDiacritics(this string stringToDiatritics)
        {
            if (string.IsNullOrEmpty(stringToDiatritics.Trim()))
                return stringToDiatritics;

            var diacriticChecked = string.Empty;

            foreach (var c in stringToDiatritics.ToCharArray())
            {
                var diac = Diacritics.FirstOrDefault(o => o.Value.ToCharArray().Contains(c));
                if (string.IsNullOrEmpty(diac.Key))
                    continue;

                //Prevent from doing same letter/Diacritic more than one time
                if (diacriticChecked.Contains(diac.Key))
                    continue;

                diacriticChecked += diac.Key;

                stringToDiatritics = stringToDiatritics.Replace(c.ToString(), "[" + diac.Value + "]");
            }

            stringToDiatritics = "%" + stringToDiatritics + "%";
            return stringToDiatritics;
        }
    }

Herhangi birinizin bu yöntemi geliştirmek için öneriniz varsa, lütfen sizi duymak isterim.

Geç saatlere kadar, ancak SQL Like tarzı joker karakterleri kullanarak Dize karşılaştırmaları yapabilmek için bunu birlikte attım:

public static class StringLikeExtensions
{
    /// <summary>
    /// Tests a string to be Like another string containing SQL Like style wildcards
    /// </summary>
    /// <param name="value">string to be searched</param>
    /// <param name="searchString">the search string containing wildcards</param>
    /// <returns>value.Like(searchString)</returns>
    /// <example>value.Like("a")</example>
    /// <example>value.Like("a%")</example>
    /// <example>value.Like("%b")</example>
    /// <example>value.Like("a%b")</example>
    /// <example>value.Like("a%b%c")</example>
    /// <remarks>base author -- Ruard van Elburg from StackOverflow, modifications by dvn</remarks>
    /// <remarks>converted to a String extension by sja</remarks>
    /// <seealso cref="/programming/1040380/wildcard-search-for-linq"/>
    public static bool Like(this String value, string searchString)
    {
        bool result = false;

        var likeParts = searchString.Split(new char[] { '%' });

        for (int i = 0; i < likeParts.Length; i++)
        {
            if (likeParts[i] == String.Empty)
            {
                continue;   // "a%"
            }

            if (i == 0)
            {
                if (likeParts.Length == 1) // "a"
                {
                    result = value.Equals(likeParts[i], StringComparison.OrdinalIgnoreCase);
                }
                else // "a%" or "a%b"
                {
                    result = value.StartsWith(likeParts[i], StringComparison.OrdinalIgnoreCase);
                }
            }
            else if (i == likeParts.Length - 1) // "a%b" or "%b"
            {
                result &= value.EndsWith(likeParts[i], StringComparison.OrdinalIgnoreCase);
            }
            else // "a%b%c"
            {
                int current = value.IndexOf(likeParts[i], StringComparison.OrdinalIgnoreCase);
                int previous = value.IndexOf(likeParts[i - 1], StringComparison.OrdinalIgnoreCase);
                result &= previous < current;
            }
        }

        return result;
    }

    /// <summary>
    /// Tests a string containing SQL Like style wildcards to be ReverseLike another string 
    /// </summary>
    /// <param name="value">search string containing wildcards</param>
    /// <param name="compareString">string to be compared</param>
    /// <returns>value.ReverseLike(compareString)</returns>
    /// <example>value.ReverseLike("a")</example>
    /// <example>value.ReverseLike("abc")</example>
    /// <example>value.ReverseLike("ab")</example>
    /// <example>value.ReverseLike("axb")</example>
    /// <example>value.ReverseLike("axbyc")</example>
    /// <remarks>reversed logic of Like String extension</remarks>
    public static bool ReverseLike(this String value, string compareString)
    {
        bool result = false;

        var likeParts = value.Split(new char[] {'%'});

        for (int i = 0; i < likeParts.Length; i++)
        {
            if (likeParts[i] == String.Empty)
            {
                continue;   // "a%"
            }

            if (i == 0)
            {
                if (likeParts.Length == 1) // "a"
                {
                    result = compareString.Equals(likeParts[i], StringComparison.OrdinalIgnoreCase);
                }
                else // "a%" or "a%b"
                {
                    result = compareString.StartsWith(likeParts[i], StringComparison.OrdinalIgnoreCase);
                }
            }
            else if (i == likeParts.Length - 1) // "a%b" or "%b"
            {
                result &= compareString.EndsWith(likeParts[i], StringComparison.OrdinalIgnoreCase);
            }
            else // "a%b%c"
            {
                int current = compareString.IndexOf(likeParts[i], StringComparison.OrdinalIgnoreCase);
                int previous = compareString.IndexOf(likeParts[i - 1], StringComparison.OrdinalIgnoreCase);
                result &= previous < current;
            }
        }

        return result;
    }
}