Làm thế nào để làm SQL Like% trong Linq?

Tôi có một quy trình trong SQL mà tôi đang cố gắng biến thành Linq:

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

Dòng tôi quan tâm nhất là:

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

Tôi có một cột lưu trữ thứ bậc như / 1/3/12 / chẳng hạn, vì vậy tôi chỉ sử dụng% / 12 /% để tìm kiếm nó.

Câu hỏi của tôi là, Linq hoặc .NET tương đương với việc sử dụng dấu phần trăm là gì?

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

Bạn cũng có thể sử dụng .StartsWith()hoặc .EndsWith().

Dùng cái này:

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

Tôi giả sử bạn đang sử dụng Linq-to-SQL * (xem ghi chú bên dưới). Nếu vậy, hãy sử dụng string.Contains, string.StartsWith và string.EndsWith để tạo SQL sử dụng toán tử SQL THÍCH.

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 }

hoặc là

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

Lưu ý: * = nếu bạn đang sử dụng Khung thực thể ADO.Net (EF / L2E) trong .net 3.5, hãy lưu ý rằng nó sẽ không thực hiện bản dịch giống như Linq-to-SQL. Mặc dù L2S thực hiện một bản dịch phù hợp, L2E v1 (3.5) sẽ dịch thành biểu thức t-sql sẽ buộc quét toàn bộ bảng trên bảng mà bạn đang truy vấn trừ khi có một bộ phân biệt đối xử tốt hơn trong mệnh đề hoặc bộ lọc tham gia của bạn.
Cập nhật: Điều này được cố định trong EF / L2E v4 (.net 4.0), do đó, nó sẽ tạo ra một SQL THÍCH giống như L2S.

Nếu bạn đang sử dụng VB.NET, thì câu trả lời sẽ là "*". Đây là mệnh đề where của bạn sẽ như thế nào ...

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

Lưu ý: "*" Khớp 0 hoặc nhiều ký tự. Đây là bài viết msDN cho toán tử Like .

IndexOf cũng hoạt động với tôi

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

Sử dụng mã như vậy

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

Lõi .NET hiện có EF.Functions.Like

Trong trường hợp bạn không khớp chuỗi số, luôn luôn có trường hợp phổ biến:

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

Tôi luôn luôn làm điều này:

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

Tôi biết tôi không sử dụng câu lệnh like nhưng nó hoạt động tốt trong nền là điều này được dịch thành truy vấn với câu lệnh like.

Hãy thử nó, nó hoạt động tốt với tôi

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

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

Chứa được sử dụng trong Linq, Giống như Like được sử dụng trong SQL.

string _search="/12/";

. . .

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

Bạn có thể viết tập lệnh SQL của mình trong Linq như sau:

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

Đối với những người ở đây như tôi đang tìm cách chuyển sang phương thức "SQL Like" trong LINQ, tôi đã làm việc rất tốt.

Tôi đang ở trong trường hợp tôi không thể thay đổi Cơ sở dữ liệu theo bất kỳ cách nào để thay đổi đối chiếu cột. Vì vậy, tôi phải tìm một cách trong LINQ của mình để làm điều đó.

Tôi đang sử dụng phương thức SqlFunctions.PatIndexphù thủy phương thức trợ giúp hoạt động tương tự như toán tử SQL THÍCH thực sự.

Đầu tiên tôi cần liệt kê tất cả các dấu phụ có thể (một từ mà tôi vừa học) trong giá trị tìm kiếm để có được một cái gì đó như:

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

và sau đó trong LINQ cho ví dụ:

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

Vì vậy, đối với nhu cầu của tôi, tôi đã viết một phương thức Trợ giúp / Gia hạn

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

Nếu bất kỳ ai trong số các bạn có đề xuất cải tiến phương pháp này, tôi sẽ vui lòng nghe bạn.

Đã muộn, nhưng tôi đã kết hợp nó để có thể thực hiện so sánh Chuỗi bằng cách sử dụng các ký tự đại diện kiểu SQL Like:

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