Comment faire SQL comme % in Linq?

utilisez ceci:

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

je suppose que vous utilisez Linq-to-SQL* (Voir note ci-dessous). Si oui, utilisez de la ficelle.Contient de la chaîne.StartsWith, et de la corde.EndsWith pour générer SQL qui utilise le SQL comme opérateur.

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 }

Note: * = si vous utilisez le ADO.Net Entity Framework (EF / L2E).net 3.5, sachez qu'il ne fera pas la même traduction que Linq-to-SQL. Bien que L2S fasse une traduction correcte, L2E v1 (3.5) se traduira par une expression T-sql qui forcera un scan complet de la table que vous interrogez à moins qu'il n'y ait un autre meilleur discriminateur dans votre clause where ou joindre les filtres.

mise à Jour: Ceci est corrigé dans les EF/L2E v4 (.net 4.0), donc, il va générer un SQL tels que, tout COMME L2S.

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

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

Note: "* " correspond à zéro caractère ou plus. Voici l'article msdn pour l'opérateur similaire .

l'index des puits fonctionne pour moi aussi

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

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

dans le cas où vous n'êtes pas assorti de chaînes numériques, toujours bon d'avoir cas commun:

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

Essayer, cela fonctionne très bien pour moi

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

je fais toujours ceci:

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

je sais que je n'utilise pas l'instruction like mais c'est très bien en arrière-plan que cela se traduit dans une requête avec une instruction like.

Contient est utilisé dans Linq ,tout comme Comme est utilisé en 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, comme moi, sont à la recherche d'une méthode" SQL Like " À LINQ, J'ai quelque chose qui fonctionne très bien.

je suis dans un cas où je ne peux pas modifier la base de données de quelque manière que ce soit pour changer la collation de colonne. Donc je dois trouver un moyen dans mon LINQ pour le faire.

j'utilise la méthode helper SqlFunctions.PatIndex witch act similarly to the real SQL LIKE operator.

D'abord j'ai besoin énumérer toutes les 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

et ensuite à 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 l'un d'entre vous a une suggestion pour améliorer cette méthode, je serai heureux de vous entendre.

. le noyau net a maintenant EF.Functions.Like