.net - recorrer - usar linq en datatable

¿Cómo hacer SQL como% en linq?

Question

Tengo un procedimiento en SQL que estoy intentando convertir en Linq:

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

La línea que más me preocupa es:

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

Tengo una columna que almacena la jerarquía como / 1/3/12 / por ejemplo, así que solo uso% / 12 /% para buscarla.

Mi pregunta es, ¿cuál es el equivalente de Linq o .NET al uso del signo de porcentaje?

Answer 1

.NET Core ahora tiene EF.Functions.Like

Answer 2

Bueno, el índice también funciona para mí.

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

Answer 3

En caso de no coincidir con cadenas numéricas, siempre es bueno tener un caso común:

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

Answer 4

Para aquellos que caen aquí como yo buscando una forma de un método "SQL Like" en LINQ, tengo algo que está funcionando muy bien.

Estoy en un caso en el que no puedo alterar la base de datos de ninguna manera para cambiar la intercalación de columnas. Así que tengo que encontrar una manera en mi LINQ para hacerlo.

Estoy usando el método auxiliar SqlFunctions.PatIndex que actúa de manera similar al operador LIKE real de SQL.

Primero necesito enumerar todos los diacríticos posibles (una palabra que acabo de aprender) en el valor de búsqueda para obtener 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

y luego en LINQ por ejemplo:

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

Así que para mis necesidades he escrito un método de ayuda / extensió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;
        }
    }

Si alguno de ustedes tiene alguna sugerencia para mejorar este método, estaré encantado de escucharlo.

Answer 5

Prueba esto, esto funciona bien para mi

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

Answer 6

Si está utilizando VB.NET, entonces la respuesta sería "*". Así es como se vería tu cláusula where ...

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

Nota: "*" coincide con cero o más caracteres. Aquí está el artículo msdn para el operador Like .

Answer 7

Siempre hago esto:

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

Sé que no uso la declaración como, pero funciona bien en el fondo, esto se traduce en una consulta con una declaración como.

Answer 8

Supongo que está utilizando Linq-to-SQL * (vea la nota a continuación). Si es así, use string.Contains, string.StartsWith y string.EndsWith para generar SQL que use el operador LIKE de 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 }

o

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

Nota: * = si está utilizando ADO.Net Entity Framework (EF / L2E) en .net 3.5, tenga en cuenta que no hará la misma traducción que Linq-to-SQL. Aunque L2S realiza una traducción adecuada, L2E v1 (3.5) se traducirá en una expresión t-sql que forzará un escaneo completo de la tabla en la tabla que está consultando a menos que haya otro discriminador mejor en su cláusula where o filtros de combinación.
Actualización: esto se soluciona en EF / L2E v4 (.net 4.0), por lo que generará un SQL LIKE al igual que L2S.

Answer 9

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

Answer 10

Utilizar esta:

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

Answer 11

Contiene se usa en Linq, al igual que Like se usa en SQL.

string _search="/12/";

. . .

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

Puede escribir su script SQL en Linq de la siguiente manera:

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

Answer 12

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

También puede usar .StartsWith() o .EndsWith() .