Como fazer o SQL Like% no Linq?

Eu tenho um procedimento no SQL que estou tentando transformar em Linq:

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

A linha que mais me preocupa é:

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

Eu tenho uma coluna que armazena a hierarquia como / 1/3/12 / por exemplo, então eu apenas uso% / 12 /% para procurá-la.

Minha pergunta é: qual é o equivalente do Linq ou .NET para usar o sinal de porcentagem?

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

Você também pode usar .StartsWith()ou .EndsWith().

Usa isto:

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

Suponho que você esteja usando o Linq-to-SQL * (veja a nota abaixo). Nesse caso, use string.Contains, string.StartsWith e string.EndsWith para gerar SQL que use o operador 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 }

ou

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

Nota: * = se você estiver usando o ADO.Net Entity Framework (EF / L2E) no .net 3.5, saiba que ele não fará a mesma tradução que o Linq-to-SQL. Embora o L2S faça uma tradução adequada, o L2E v1 (3.5) se traduzirá em uma expressão t-sql que forçará uma verificação completa da tabela na tabela que você está consultando, a menos que haja outro discriminador melhor na sua cláusula where ou nos filtros de associação.
Atualização: Isso é corrigido no EF / L2E v4 (.net 4.0), portanto, gera um SQL LIKE exatamente como o L2S.

Se você estiver usando o VB.NET, a resposta seria "*". Aqui está a aparência da sua cláusula where ...

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

Nota: "*" Corresponde a zero ou mais caracteres. Aqui está o artigo msdn para o operador Like .

Bem indexOf funciona para mim também

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

Use esse código

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

O núcleo do .NET agora tem EF.Functions.Like

Caso você não esteja combinando cadeias numéricas, é sempre bom ter maiúsculas e minúsculas:

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

Eu sempre faço isso:

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

Eu sei que não uso a instrução like, mas funciona bem em segundo plano. Isso é traduzido em uma consulta com uma instrução like.

Tente isso, isso funciona bem para mim

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

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

Contém é usado no Linq, assim como é usado no SQL.

string _search="/12/";

. . .

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

Você pode escrever seu script SQL no Linq da seguinte forma:

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

Para aqueles que caem aqui como eu procurando um método "SQL Like" no LINQ, tenho algo que está funcionando muito bem.

Estou em um caso em que não posso alterar o banco de dados de forma alguma para alterar o agrupamento de colunas. Então, eu tenho que encontrar uma maneira no meu LINQ para fazer isso.

Estou usando o método auxiliar SqlFunctions.PatIndexque age de maneira semelhante ao operador SQL LIKE real.

Primeiro, preciso enumerar todos os diacríticos possíveis (uma palavra que acabei de aprender) no valor da pesquisa para obter algo como:

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

e depois no LINQ, por exemplo:

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

Então, para as minhas necessidades, escrevi um método 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;
        }
    }

Se algum de vocês tiver alguma sugestão para aprimorar esse método, ficarei feliz em ouvi-lo.

Muito tarde, mas eu juntei isso para poder fazer comparações de String usando caracteres curinga do estilo 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;
    }
}