Bagaimana melakukan SQL Like% di Linq?

Saya memiliki prosedur dalam SQL yang saya coba ubah menjadi Linq:

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

Garis yang paling saya perhatikan adalah:

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

Saya memiliki kolom yang menyimpan hierarki seperti / 1/3/12 / misalnya jadi saya hanya menggunakan% / 12 /% untuk mencarinya.

Pertanyaan saya adalah, apa yang setara dengan Linq atau .NET dengan menggunakan tanda persen?

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

Anda juga dapat menggunakan .StartsWith()atau .EndsWith().

Gunakan ini:

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

Saya berasumsi Anda menggunakan Linq-to-SQL * (lihat catatan di bawah). Jika demikian, gunakan string.Contains, string.StartsWith, dan string.EndsWith untuk menghasilkan SQL yang menggunakan operator SQL LIKE.

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 }

atau

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

Catatan: * = jika Anda menggunakan ADO.Net Entity Framework (EF / L2E) di .net 3.5, perlu diketahui bahwa ia tidak akan melakukan terjemahan yang sama dengan Linq-to-SQL. Meskipun L2S melakukan terjemahan yang tepat, L2E v1 (3.5) akan menerjemahkan ke dalam ekspresi t-sql yang akan memaksa pemindaian tabel penuh pada tabel yang Anda query kecuali ada pembeda lain yang lebih baik di mana klausa Anda atau filter bergabung.
Pembaruan: Ini diperbaiki di EF / L2E v4 (.net 4.0), sehingga akan menghasilkan SEPERTI SQL seperti halnya L2S.

Jika Anda menggunakan VB.NET, maka jawabannya adalah "*". Berikut adalah di mana klausa Anda akan terlihat seperti ...

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

Catatan: "*" Cocok dengan nol atau lebih karakter. Ini adalah artikel msdn untuk operator Suka .

Yah indexOf bekerja untuk saya juga

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

Gunakan kode seperti itu

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;
}

Inti NET sekarang EF.Functions.Like

Jika Anda tidak cocok dengan string numerik, selalu baik untuk memiliki kasus umum:

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

Saya selalu melakukan ini:

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

Saya tahu saya tidak menggunakan pernyataan like tetapi berfungsi dengan baik di latar belakang apakah ini diterjemahkan ke dalam kueri dengan pernyataan like.

Coba ini, ini berfungsi baik untuk saya

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

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

Berisi digunakan dalam Linq, Sama seperti Suka digunakan dalam SQL.

string _search="/12/";

. . .

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

Anda dapat menulis skrip SQL di Linq sebagai berikut:

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

Bagi mereka yang tumbang di sini seperti saya mencari cara untuk metode "Seperti SQL" di LINQ, saya memiliki sesuatu yang berfungsi dengan sangat baik.

Saya dalam kasus di mana saya tidak dapat mengubah Database dengan cara apa pun untuk mengubah susunan kolom. Jadi saya sudah menemukan cara di LINQ saya untuk melakukannya.

Saya menggunakan metode pembantu SqlFunctions.PatIndextindakan penyihir mirip dengan operator SEPERTI SQL nyata.

Pertama, saya perlu menghitung semua diakritik yang mungkin (kata yang baru saya pelajari) dalam nilai pencarian untuk mendapatkan sesuatu seperti:

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

dan kemudian di LINQ untuk contoh:

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();

Jadi untuk kebutuhan saya, saya telah menulis metode Helper / Extension

   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;
        }
    }

Jika ada di antara Anda yang memiliki saran untuk meningkatkan metode ini, saya akan senang mendengarkan Anda.

Jauh terlambat, tapi saya melemparkan ini bersama untuk bisa melakukan perbandingan String menggunakan wildcard gaya Suka SQL:

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;
    }
}