Come fare SQL Come% in Linq?

Question

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 Sono molto preoccupato è:

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

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

La mia domanda è, qual è il Linq o .NET equivalente all'utilizzo del segno di percentuale?

Answer 1

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

È anche possibile utilizzare .StartsWith() o .EndsWith().

Answer 2

Suppongo che tu stia utilizzando 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 l'ADO.Net Entity Framework (EF/L2E) in .net 3.5, essere consapevoli del fatto che non farà lo stesso traduzione come Linq-to-SQL. Sebbene L2S faccia una traduzione corretta, L2E v1 (3.5) si tradurrà in un'espressione t-sql che imporrà una scansione completa della tabella sulla tabella su cui si sta eseguendo la query, a meno che non ci sia un altro discriminatore migliore nella clausola where o nei filtri join.
Aggiornamento: Questo è corretto in EF/L2E v4 (.net 4.0), quindi genererà un SQL LIKE proprio come fa L2S.

Answer 3

Se si utilizza VB.NET, la risposta sarà "*". Ecco come dovrebbe apparire la tua clausola where ...

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

Nota: "*" Corrisponde a zero o più caratteri. Here is the msdn article for the Like operator.

Answer 4

Utilizzare questa:

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

Answer 5

Nel caso in cui ti è capitato di averne bisogno in LINQ to Entities, ecco come: funziona http://jendaperl.blogspot.com/2011/02/like-in-linq-to-entities.html

Answer 6

Bene indexOf anche per me

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

Answer 7

Utilizzando predicate builder effettuare query Linq è una buona pratica quando si creano query dinamiche con molte di queste condizioni. Vedi this codeproject article anche

Answer 8

Prova questa, questo funziona bene per me

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

Answer 9

faccio sempre questo:

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

lo so io non uso la dichiarazione del genere, ma è un lavoro bene in lo sfondo è questo tradotto in una query con una dichiarazione simile.

Answer 10

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

Answer 11

Contiene viene utilizzato in Linq, Proprio come Come viene utilizzato in SQL.

string _search="/12/"; 

. . .

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

È possibile scrivere lo script SQL in LINQ come a seguire:

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

Answer 12

Nel caso in cui non sono corrispondenti stringhe numeriche, sempre bene avere caso comune:

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

Answer 13

Per coloro come se stessi qui come me, cercando un modo per un metodo "SQL Like" in LINQ, ho qualcosa che funziona molto bene.

Sono in un caso in cui non è possibile 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 di supporto SqlFunctions.PatIndex strega agire in modo simile al vero operatore SQL LIKE.

prima ho bisogno elencare tutti i possibili segni diacritici (una parola che ho appena appreso) del valore di ricerca per ottenere qualcosa di simile:

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

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 suggerito di migliorare questo metodo, sarò felice di sentirvi.