Comment faire SQL Like% dans Linq?

J'ai une procédure en SQL que j'essaye de transformer 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 ligne qui me préoccupe le plus est:

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

J'ai une colonne qui stocke la hiérarchie comme / 1/3/12 / par exemple, donc j'utilise simplement% / 12 /% pour la rechercher.

Ma question est, quel est l'équivalent Linq ou .NET à utiliser le signe pourcentage?

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

Vous pouvez également utiliser .StartsWith()ou .EndsWith().

Utilisez ceci:

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

Je suppose que vous utilisez Linq-to-SQL * (voir la note ci-dessous). Si tel est le cas, utilisez string.Contains, string.StartsWith et string.EndsWith pour générer du SQL qui utilise l'opérateur 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 }

Remarque: * = si vous utilisez ADO.Net Entity Framework (EF / L2E) dans .net 3.5, sachez qu'il ne fera pas la même traduction que Linq-to-SQL. Bien que L2S effectue une traduction appropriée, L2E v1 (3.5) se traduira par une expression t-sql qui forcera une analyse complète de la table sur la table que vous interrogez, sauf s'il existe un autre meilleur discriminateur dans votre clause where ou vos filtres de jointure.
Mise à jour: Ceci est corrigé dans EF / L2E v4 (.net 4.0), donc il générera un SQL LIKE tout comme L2S.

Si vous utilisez VB.NET, la réponse serait "*". Voici à quoi ressemblerait votre clause where ...

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

Remarque: "*" Correspond à zéro ou plusieurs caractères. Voici l'article msdn pour l'opérateur Like .

Eh bien, l'index fonctionne aussi pour moi

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

Utilisez un tel code

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

Le noyau .NET a maintenant EF.Functions.Like

Dans le cas où vous ne correspondez pas à des chaînes numériques, il est toujours bon d'avoir une casse commune:

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

Je fais toujours ça:

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

Je sais que je n'utilise pas la même déclaration, mais cela fonctionne très bien en arrière-plan est-ce traduit en une requête avec une déclaration similaire.

Essayez ceci, cela fonctionne bien pour moi

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

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

Contient est utilisé dans Linq, tout comme Like est utilisé dans SQL.

string _search="/12/";

. . .

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

Vous pouvez écrire votre script SQL dans Linq comme suit:

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

Pour ceux qui dégringolent ici comme moi à la recherche d'un moyen pour une méthode "SQL Like" dans LINQ, j'ai quelque chose qui fonctionne très bien.

Je suis dans un cas où je ne peux en aucun cas modifier la base de données pour modifier le classement des colonnes. Je dois donc trouver un moyen dans mon LINQ de le faire.

J'utilise la méthode d'assistance SqlFunctions.PatIndexqui agit de la même manière que le véritable opérateur SQL LIKE.

J'ai d'abord besoin d'énumérer tous les signes diacritiques possibles (un mot que je viens d'apprendre) dans la valeur de recherche pour obtenir quelque chose comme:

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

puis dans LINQ par exemple:

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

Donc, pour mes besoins, j'ai écrit une méthode 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;
        }
    }

Si vous avez des suggestions pour améliorer cette méthode, je serai ravi de vous entendre.

Bien en retard, mais j'ai jeté cela ensemble pour pouvoir faire des comparaisons de chaînes en utilisant des caractères génériques de style 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;
    }
}