Come fare a SQL come% in Linq?

Ho una procedura in SQL che sto cercando di trasformare in 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 linea di cui mi preoccupo di più è:

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

Ho una colonna che memorizza la gerarchia come / 1/3/12 / ad esempio, quindi uso solo% / 12 /% per cercarla.

La mia domanda è: qual è l'equivalente di Linq o .NET nell'uso del segno di percentuale?

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

Puoi anche usare .StartsWith()o .EndsWith().

Usa questo:

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

Suppongo che tu stia usando Linq-to-SQL * (vedi nota sotto). In tal caso, utilizzare string.Contains, string.StartsWith e string.EndsWith per generare SQL che utilizza l'operatore 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 }

o

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

Nota: * = se si utilizza ADO.Net Entity Framework (EF / L2E) in .net 3.5, tenere presente che non eseguirà la stessa traduzione di Linq-to-SQL. Sebbene L2S esegua una traduzione corretta, L2E v1 (3.5) si tradurrà in un'espressione t-sql che imporrà una scansione completa della tabella sulla tabella che stai interrogando, a meno che non ci sia un altro migliore discriminatore nella clausola where o nei filtri join.
Aggiornamento: risolto in EF / L2E v4 (.net 4.0), quindi genererà un LIKE SQL proprio come fa L2S.

Se si utilizza VB.NET, la risposta sarebbe "*". Ecco come sarebbe la tua clausola where ...

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

Nota: "*" Corrisponde a zero o più caratteri. Ecco l'articolo msdn per l'operatore Like .

Bene indexOf funziona anche per me

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

Usa tale codice

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

.NET core ora ha EF.Functions.Like

Nel caso in cui non abbini stringhe numeriche, è sempre bene avere un caso comune:

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

Faccio sempre questo:

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

So di non usare l'istruzione like ma funziona benissimo in background se questo viene tradotto in una query con un'istruzione like.

Prova questo, questo funziona bene per me

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

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

Contiene è usato in Linq, proprio come Like è usato in SQL.

string _search="/12/";

. . .

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

Puoi scrivere il tuo script SQL in Linq come segue:

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

Per quelli che sono qui come me che cercano un modo per un metodo "SQL Like" in LINQ, ho qualcosa che funziona molto bene.

Sono in un caso in cui non posso modificare il database in alcun modo per modificare le regole di confronto delle colonne. Quindi devo trovare un modo nel mio LINQ per farlo.

Sto usando il metodo helper SqlFunctions.PatIndexche agisce in modo simile al vero operatore SQL LIKE.

Per prima cosa ho bisogno di elencare tutti i possibili segni diacritici (una parola che ho appena imparato) nel valore di ricerca per ottenere qualcosa del tipo:

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

e poi in LINQ per esempio:

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

Quindi per le mie esigenze ho scritto un metodo 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 qualcuno di voi ha suggerimenti per migliorare questo metodo, sarò felice di ascoltarti.

Molto tardi, ma ho combinato questo per essere in grado di fare confronti con String usando i caratteri jolly in stile 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;
    }
}