El blog de programación con Delphi y .NET

En muchas ocasiones cuando estamos desarrollando una aplicación necesitamos obtener los elementos de una colección que contengan o no un conjunto de elementos.

Para esta tarea, en LINQ hacemos uso de la extensión Contains.

Para poner un ejemplo similar y así pode entender de que hablo observe la siguiente instrucción SQL:

Select * from Tabla Where campo Not In (‘Valor1’,’Valor2’….)

En esta instrucción SQL estamos obteniendo los valores de la tabla que no estén dentro del conjunto de valores que estamos especificando.

Vamos a ver como lograr algo similar utilizando LINQ.

El siguiente ejemplo es únicamente demostrativo y está escrito en Delphi Prism.

Comenzamos por crear una clase muy simple de productos frutales por ejemplo:

type
TProducto = public class
public
   property fruta : String;
end;

Y el código de ejemplo demostrativo de LINQ y Contains sería:

var frutas : array of String := ['Peras','Platanos'];
var ColeccionProductos : List<TProducto> := new List<TProducto>();
ColeccionProductos.Add(new TProducto(fruta := 'Naranjas'));
ColeccionProductos.Add(new TProducto(fruta := 'Peras'));
ColeccionProductos.Add(new TProducto(fruta := 'Limones'));
ColeccionProductos.Add(new TProducto(fruta := 'Platanos'));
var ElementosProductos := from elemento in ColeccionProductos
                                     where not (frutas.Contains(elemento.fruta.ToString()))
                                     select elemento;
ColeccionProductos :=  ElementosProductos.ToList();
for each item in ColeccionProductos do
   MessageBox.Show(item.fruta);

Como podemos ver en este ejemplo, creamos una colección de frutas y una matriz con el nombre de dos frutas.
Lo que queremos obtener son todas las frutas que no están contenidas en la matriz.
Es decir, todas las frutas que no son ni Peras ni Plátanos.
En SQL estándar serían las frutas NOT IN (‘Peras’, ‘Platanos’).
Adicionalmente, también podemos hacer uso de las funciones Lambda, por lo que todo el funcionamiento anterior, se resumiría de la siguiente manera (equivalente de la anterior):

var frutas : array of String := ['Peras','Platanos'];
var ColeccionProductos : List<TProducto> := new List<TProducto>();
ColeccionProductos.Add(new TProducto(fruta := 'Naranjas'));
ColeccionProductos.Add(new TProducto(fruta := 'Peras'));
ColeccionProductos.Add(new TProducto(fruta := 'Limones'));
ColeccionProductos.Add(new TProducto(fruta := 'Platanos'));
ColeccionProductos := ColeccionProductos.Where((n) -> not (frutas.Contains(n.fruta.ToString()))).ToList();
for each item in ColeccionProductos do
  MessageBox.Show(item.fruta);

Espero que quede clara (para quien lo necesite) la funcionalidad, beneficios y usos de Contains en LINQ.

En esta ocasión quiero hablar de las expresiones regulares, una herramienta muy útil pero también un poco complicado de comprender.

Las expresiones regulares son una manera estándar de buscar y reemplazar de manera opcional apariciones de subcadenas y patrones de texto. Si no conoces las expresiones regulares, sólo piensa en los caracteres comodines que usa el indicador de comandos para indicar un grupo de archivos (como *.txt) o en los caracteres especiales que puede usar con el operador Like en las consultas SQL:

SELECT nombre,ciudad FROM Clientes WHERE nombre LIKE “A%”

Muchos expertos en computación han investigado a fondo las expresiones regulares, y algunos lenguajes de programación están excesivamente basados en ellas.  A pesar de su mucha utilidad los programadores de Microsoft Windows rara vez usan las expresiones regulares, tal vez porque su sintaxis no es muy clara.

Aspectos Generales de las expresiones regulares

Microsoft .NET Framework viene con un motor de expresiones regulares muy poderoso al que se puede acceder desde cualquier lenguaje .NET, por lo que podemos usar es poder del análisis sintáctico de lenguajes como Perl sin tener que abandonar nuestro lenguaje favorito.
Fundamentos de las expresiones regulares
Regex es la clase más importante de este grupo, y cualquier código de expresión regular crea una instancia al menos de un objeto de esta clase (o usa uno de los métodos estáticos de Regex). Este objeto representa una expresión regular inmutable. Crearemos una instancia al pasar el patrón de búsqueda:

var re : Regex := new Regex('[aeiou]\d');

El método Matches del objeto Regex aplica la expresión regular a la cadena pasada como parámetro; devuelve un objeto MatchCollection, una colección de sólo lectura que representa todas las coincidencias que no se superponen:

var re : Regex := new Regex('[aeiou]\d');
//Esta cadena de entrada contiene tres grupos
//que coinciden en el Regex
var texto : String:= 'a1:= a1 + e2';
//Obtiene la colección de coincidencias
var mc : MatchCollection := re.Matches(texto);
//¿Cuantas apariciones encontramos?
Console.WriteLine('{0} concidencias',mc.Count);
Console.ReadLine;

También podemos pasarle al método Matches en segundo parámetro, que se interpreta como el índice donde comienza la búsqueda.
El objeto matchCollection contiene objetos Match individuales, que exponen propiedades como:

• Value.- La cadena coincidente que se encontró.
• Index.- La posición de la cadena coincidente en la cadena de entrada.
• Length.- La longitud de la cadena coincidente, que es útil cuando la expresión regular coincide con cadenas de diversas longitudes.

El código anterior despliega estas líneas en la ventana de consola:

a1 en la posición 0
a1 en la posición 5
e2 en la posición 10

El lenguaje de expresiones regulares

En las siguientes tablas presento una lista de todas las construcciones legales como patrones de expresiones regulares, agrupados en las siguientes categorías:

• Caracteres de escape.- Se usan para sustituir caracteres individuales. Los necesitamos para manejar los caracteres que no se imprimen (como los caracteres de nueva línea y de tabulador) y para proporcionar versiones de escape para los caracteres que tienen un significado especial en patrones de expresiones regulares. Junto con las sustituciones, éstas son las únicas secuencias que pueden aparecer en un modelo de reemplazo.

• Clases de caracteres.- Ofrecen una manera de hacer coincidir un carácter de un grupo que se especifica entre corchetes como en el ejemplo de [aeiou]. No necesita tener caracteres especiales de escape cuando aparecen entre corchetes, con excepción de los casos del guión y el corchete de cierre, que son los únicos caracteres que tienen un significado especial entre corchetes. Por ejemplo, [()[\]{}] hace coincidir paréntesis, corchetes y llaves de apertura y cierre. (Hay que observar que el carácter] es de escape, pero el carácter [ no lo es.)

• Aserciones atómicas de ancho cero.- Especifican dónde debe ir la cadena coincidente pero no consumen caracteres. Por ejemplo, la expresión regular abc$ coincide con cualquier palabra abc que esté inmediatamente antes del final de una línea sin coincidir con el final de la línea.

• Cuantificadores.- Especifican que una subexpresión se debe repetir un número de veces determinado. Un cuantificador particular se aplica al carácter, clase de caracteres o grupo que lo precede inmediatamente. Por ejemplo, \w+ corresponde a todas las palabras con uno o más caracteres, mientras que \w{3,} corresponde a todas las palabras con tres caracteres, cuando menos. Los cuantificadores se dividen en dos categorías: expansivos y laxos. Un cuantificador expansivo, como * y +, siempre coincide con la mayor cantidad de caracteres posible, mientras que uno laxo, como *? Y +?, intenta coincidir con la menor cantidad de caracteres que sea posible.

• Construcciones de agrupamiento.- Pueden capturar y nombrar grupos de subexpresiones, además de incrementar la eficiencia de las expresiones regulares con modificadores de búsquedas anticipadas y búsquedas tardías sin captura. Por ejemplo, (abc)+ coincide con secuencias repetidas de la cadena “abc”, (?<total>\d+) coincide con un grupo de uno o más dígitos consecutivos y le asigna el nombre total, que se puede usar después dentro del mismo modelo de expresión regular o para sustitución.

• Sustituciones.- Sólo se pueden usar dentro de un modelo de reemplazo y, junto con los caracteres de escape, son las únicas construcciones que se pueden usar en patrones de reemplazo. Por ejemplo, cuando la secuencia ${total} aparece en un modelo de reemplazo, inserta el valor del grupo llamado total. Los paréntesis no tienen un significado especial en un modelo de reemplazo, así que no necesita caracteres de escape.

• Construcciones de referencia inversa.- Nos permiten hacer referencia a un grupo anterior de caracteres en el modelo de expresión regular usando su número o nombre de grupo. Podemos usar estas construcciones como una manera de decir “coincidir otra vez con los mismo”. Por ejemplo, (?<valor>\d+)=\k<valor> hace coincidir números idénticos separados por un símbolo =, como en la secuencia “123=123”.

• Construcciones de alternancia.- Proporcionan una manera de especificar opciones; por ejemplo, la secuencia “Yo (tengo|tenía)” puede hacer coincidir las cadenas “Yo tengo” y “Yo tenía”.

• Construcciones diversas.- Incluyen que permiten modificar una o más opciones de una expresión regular en medio del modelo. Por ejemplo, A(?i)BC coincide con todas las variantes de la palabra ABC que comienzan con A mayúscula (como Abc, ABc, AbC, y ABC).