.net 如何在Linq中执行类似SQL%的操作？_.net_Linq_Tsql_Linq To Entities_Sql Like

.net 如何在Linq中执行类似SQL%的操作？

.net linq tsql

.net 如何在Linq中执行类似SQL%的操作？,.net,linq,tsql,linq-to-entities,sql-like,.net,Linq,Tsql,Linq To Entities,Sql Like,我正在尝试将SQL中的一个过程转换为Linq： SELECT O.Id, O.Name as Organization FROM Organizations O JOIN OrganizationsHierarchy OH ON O.Id=OH.OrganizationsId where OH.Hierarchy like '%/12/%' 我最关心的是： where OH.Hierarchy like '%/12/%' 我有一个列存储层次结构，比如/1/3/12/，所以我只使用%/12/%

我正在尝试将SQL中的一个过程转换为Linq：

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

我最关心的是：

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

我有一个列存储层次结构，比如/1/3/12/，所以我只使用%/12/%来搜索它

我的问题是，什么是Linq或.NET等同于使用百分号

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

您也可以使用

.StartsWith（）

或

.EndsWith（）

我假设您使用的是Linq to SQL*（请参见下面的注释）。如果是，请使用string.Contains、string.StartsWith和string.EndsWith生成使用类SQL运算符的SQL

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 }

或

注意：*=如果您在.Net 3.5中使用ADO.Net实体框架（EF/L2E），请注意它不会执行与Linq到SQL相同的转换。尽管L2S进行了正确的转换，L2E v1（3.5）将转换为t-sql表达式，该表达式将强制对正在查询的表进行完整的表扫描，除非where子句或join筛选器中有其他更好的鉴别器。

更新：这在EF/L2E v4（.net 4.0）中是固定的，因此它将像L2S一样生成SQL。

如果您使用的是VB.net，那么答案将是“*”。下面是where子句的样子

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

注意：“*”匹配零个或多个字符

使用以下命令：

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

indexOf对我也很有用

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

试试这个，这个对我很好

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

我经常这样做：

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

我知道我不使用like语句，但它在后台工作正常。这是否可以转换为具有like语句的查询。

使用此类代码

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

Contains在Linq中使用，就像like在SQL中使用一样

string _search="/12/";

您可以使用Linq编写SQL脚本，如下所示：

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

如果您不匹配数字字符串，最好使用普通大小写：

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

对于像我这样在LINQ中寻找“类似SQL”方法的人，我有一个非常好的方法

在这种情况下，我无法以任何方式更改数据库以更改列排序规则。所以我必须在我的生命中找到一个方法来做这件事

我使用的是helper方法SqlFunctions.PatIndex
，其作用类似于真正的类SQL操作符

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 }

首先，我需要列举搜索值中所有可能的变音符号（我刚学过的一个单词），以获得如下结果：

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

然后以LINQ为例：

因此，为了满足我的需要，我编写了一个助手/扩展方法

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

公共静态类SqlServerHelper
{
private static readonly List Diacritics=new List（）
{
新的KeyValuePair（“A”、“Aá–AÀAÄ”），
新的KeyValuePair（“E”、“E”），
新的KeyValuePair（“U”、“UùùUÛÜÙ”），
新的KeyValuePair（“C”、“CçC椆”），
新的键值对（“I”、“IîïIÎÏ”），
新的KeyValuePair（“O”、“O”），
新的KeyValuePair（“Y”、“YŸÝýYÿ”）
};
公共静态字符串EnumarateDiacritics（此字符串StringToDiaCritics）
{
if（string.IsNullOrEmpty（stringToDiatrics.Trim（）））
回归医学；
var diacriticChecked=string.Empty；
foreach（stringtoditalitics.ToCharArray（）中的变量c）
{
var diac=Diacritics.FirstOrDefault（o=>o.Value.ToCharArray（）.Contains（c））；
if（string.IsNullOrEmpty（diac.Key））
继续；
//防止重复使用同一字母/变音符号
if（diacriticChecked.Contains（diac.Key））
继续；
diacriticChecked+=语音键；
StringToDiatrics=StringToDiatrics.Replace（c.ToString（），“[”+diac.Value+“]）；
}
StringToDiatrics=“%”+StringToDiatrics+“%”；
回归医学；
}
}

如果你们中有人建议增强此方法，我将很高兴听到您的建议。

.NET core现在有

EF.函数。如

var isMatch=EF.Functions.Like（stringThatMightMatch，pattern）；

太晚了，但我将其组合在一起，以便能够使用类似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="https://stackoverflow.com/questions/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;
    }
}

公共静态类StringLikeExtensions
{
/// 
///测试一个字符串是否与包含类似SQL样式通配符的另一个字符串相似
/// 
///要搜索的字符串
///包含通配符的搜索字符串
///value.Like（searchString）
///价值。比如（“a”）
///值。例如（“a%”）
///值。例如（“%b”）
///价值。例如（“a%b”）
///价值。例如（“a%b%c”）
///基本作者——StackOverflow的Ruard van Elburg，dvn修改
///由sja转换为字符串扩展名
/// 
公共静态bool-Like（此字符串值、字符串搜索字符串）
{
布尔结果=假；
var likeParts=searchString.Split（新字符[]{“%”）；
for（int i=0；i   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;
        }
    }


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

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="https://stackoverflow.com/questions/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;
    }
}