Operadores de Linq: Como usar los operadores Take, StartsWith, EndsWith y Contains

Volvemos a Linq dado que cuanto más lo uso más me gusta  y como ya dije anteriormente Linq seguramente es la mayor mejora que presenta ASP.NET 3.5 y por ello, hoy quería hablar de los operadores que nos aporta el Framework para poder hacer nuestras consultas más precisas.

Los operadores que vamos a ver hoy son:

  • Take
  • StartsWith
  • EndsWith
  • Contains

Estos operadores son equivalentes a operadores de SQL. Estos operadores son

  • Top
  • LIKE

Antes de empezar a ver el código, solo quiero decir que vamos a usar como fuente de datos un XML que listan todos los países con sus respectivos códigos. Para tratar este XML, vamos a usar una entidad de negocio llamada CountryInfo.

El XML, tiene este formato (eso sí con muchos más nodos):

<countries>
<country code="AF" iso="4">Afghanistan</country>
<country code="AL" iso="8">Albania</country>
<country code="DZ" iso="12">Algeria</country>
<country code="AS" iso="16">American Samoa</country>
<country code="AD" iso="20">Andorra</country>
<country code="AO" iso="24">Angola</country>
<country code="AI" iso="660">Anguilla</country>
<country code="AQ" iso="10">Antarctica</country>
<country code="AG" iso="28">Antigua And Barbuda</country>
<country code="AR" iso="32">Argentina</country>
</countries>

Y la entidad de negocio, tiene este aspecto:

public class CountryInfo
{
public string Code { get; set; }
public int IsoCode { get; set; }
public string Name { get; set; }
}

Descarga el código fuente usado y podrás ver en detalle la fuente de datos y la entidad de negocio.

El operador de Linq Take

El operador Take de Linq es el equivalente al operador Top de SQL así pues, este nos va a permitir recibir un conjunto finito de registros.

Este operador, se aplica a la consulta Linq indicándole como parámetro el número de registros que queremos obtener.

La sintaxis para aplicarlo sería la siguiente:

new List<CountryInfo>(getAllCountries().Take(numberOfCountries));

Facil verdad, pues si, como siempre el Framework nos intenta facilitar la vida. Descarga el código y podras ver con un unit test como funciona en detalle este código.

Los operadores StartsWith, EndsWith y Contains.

Los operadores de Linq StartsWith, EndsWith y Contains, equivalen al operador like de SQL, es decir, la equivalencia sería la siguiente:

  • StartsWith -> LIKE [Sp%]
  • EndsWith -> LIKE [%in]
  • Contains -> LIKE [%sp%]

Sabiendo esto, veamos ahora cual sería la sintaxis de estos operadores.

El operador de Linq StartsWith

Como hemos visto, StartsWith equivale al parte de la funcionalidad del operador LIKE (en concreto a LIKE [Sp%]) de Sql.

StartsWith, busca en el principio de una cadena y si hace matching la devuelve.

Este operador, tenemos que aplicarlo en la sentencia Where de la consulta y la sintaxis sería la siguiente:

new List<CountryInfo>(from node in _xmlContent.Descendants(NODE_COUNTRY_NAME)
where node.Value.StartsWith(searchPatterm)
select new CountryInfo()
{
Code = getValueFromAttribute(node, ATTRIBUTE_CODE_NAME),
IsoCode = Convert.ToInt32(getValueFromAttribute(node, ATTRIBUTE_ISO_NAME)),
Name = node.Value
});

Descarga el código fuente de este post y podras ver por medio de una prueba unitaria como funciona este operador.

El operador de Linq EndsWith

EndsWith (como StartsWith y Contains) tambien nos aporta parte de la funcionalidad del operador LIKE de SQL. Este busca en el final de una cadena y si hace matching la devuelve. Al igual que StartsWith, hay que aplicarlo en la sentencia Where y su sintaxis es la siguiente:

new List<CountryInfo>(from node in _xmlContent.Descendants(NODE_COUNTRY_NAME)
where node.Value.EndsWith(searchPatterm)
select new CountryInfo()
{
Code = getValueFromAttribute(node, ATTRIBUTE_CODE_NAME),
IsoCode = Convert.ToInt32(getValueFromAttribute(node, ATTRIBUTE_ISO_NAME)),
Name = node.Value
});

Descarga el código fuente de este post y podras ver por medio de una prueba unitaria como funciona el operador de Linq EndsWith.

El operador de Linq Contains

El operador de Linq Contains completa (con StartsWith y EndsWith) la funcionalidad del operador LIKE de SQL.

Contains busca una cadena dentro de otra y si hace matching la devuelve, se aplica a la sentencia Where y su sintaxis es la siguiente:

new List<CountryInfo>(from node in _xmlContent.Descendants(NODE_COUNTRY_NAME)
where node.Value.Contains(searchPatterm)
select new CountryInfo()
{
Code = getValueFromAttribute(node, ATTRIBUTE_CODE_NAME),
IsoCode = Convert.ToInt32(getValueFromAttribute(node, ATTRIBUTE_ISO_NAME)),
Name = node.Value
});

Descarga el código fuente de este post y podras ver por medio de una prueba unitaria como funciona el operador de Linq Contains.

Como veis, es muy sencillo utilizar estos operadores y de forma rápida y elegante podremos realizar consultas Linq mucho más eficientes.

Otros post sobre Linq en Adeshoras

Descargas (Downloads)

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s