May 2009 - Artículos

YACAMLQT (Yet another CAML query tool) Redux (3) in CodePlex

Bueno, esta es la última entrega a partir de hoy el proyecto se encuentra en CodePlex (yacamlqt.codeplex.com).

En esta última parte solo unas pequeñas notas para el usuario final.

Bien, para usar YACAMLQT, dentro de tus proyectos, solo hay que referenciar la dll (IdeSeg.SharePoint.Caml.QueryParser.dll)  y el uso sería el siguiente:


   1:              try
   2:              {
   3:                  var parser = new NParser(textTSql, new ASTNodeCAMLFactory());
   4:                  var generator = new CodeGenerator(parser.Parse());
   5:                  generator.Generate();
   6:                  return _formatTools.FormatXml(generator.Code);
   7:              }
   8:              catch (ParserException ex)
   9:              {
  10:                  _view.Status = ex.Message;
  11:              }
  12:              catch (ScannerException ex)
  13:              {
  14:                  _view.Status = ex.Message;
  15:              }

Instanciamos el Parser (NParser), le pasamos la consulta en TSQL (textSql) y la factoría correspondiente a lo que queremos generar, por el momento solo está disponible la de CAML, en breve completaré la de CAML.Net; Por último inyectamos el Parser en el Generador de código, llamamos al método Generate y recogemos la consulta en CAML en generator.Code.


Las posibles excepciones tanto del Parser como del generador de código se pueden atrapar con ParserException y ScannerException.


En el proyecto se incluye un pequeño subproyecto con una interfaz WinForms (no es que se me de especialmente bien)

Publicado por Carlos Segura con no comments
Archivado en:

¿Por qué son importantes los patrones? - Libros de Referencia

A estas alturas… todavía me encuentro con aplicaciones donde es imposible comprender el diseño e interpretar las intenciones del desarrollador.

Básicamente, pienso que hablan por sí solos, es decir, revelan la intención del diseño, son un lenguaje común; cuando en un equipo de desarrollo se habla en términos de patrones de código, se está hablando de las características, cualidades y restricciones que el patrón representa. Hablamos simplificando los problemas y partes del diseño de nuestras aplicaciones.

Prácticamente no hay API ó Framework (la de SharePoint es una excepción) donde no se haga uso de patrones, esto hace que el uso y comprensión así como las extensiones que realicemos sea mucho más sencillo.

“Cada patrón describe un problema que ocurre una y otra vez en nuestro ambiente y describe el corazón de la solución del problema, de esta manera podemos usar esta solución una y otra vez sin hacerlo de la misma manera dos veces” Christopher Alexander [AIS+77, page x]

Los patrones nos dicen como estructurar clases y objetos para resolver problemas, y es nuestro trabajo adaptarlos a nuestros diseños.

Y esto es lo más grande, porque esa adaptación a un problema particular no oculta las intenciones del programador, viendo que patrón se ha adaptado nos permite vislumbrar en que ha pensado a la hora de tomar decisiones.

En fin, para todos aquellos que comienzan, y para algunos que todavía… os dejo una lista de libros que son (no todos) de obligada lectura.

De arriba abajo:



* Patrones de diseño, edición en castellano de Design Patterns - Lectura obligatoria
* Design Patters (GOF Book) - Lectura obligatoria
* Analysis Patterns - Es un libro más profundo, sobre todo orientado al análisis y diseño de aplicaciones, con ejemplos (sin código) del diseño de aplicaciones de negocio y de aplicación de patrones en el diseño - Lectura Recomendada
* AAgile Principles, Patterns and Practices in C# - Para mi uno de los mejores libros que he leído, no solo hace hincapié en los principios de diseño más básicos, sino que también añade una completa referencia de los patrones más usados. - Lectura Muy Recomendada.
* Patterns of Enterprise Application Architecture - Fantástico, aquí se incluyen muchos de los patrones más usados que no se encuentran en el GOF Book, desde Active Record, Lazy Load, Unit Of Work ... aproximadamente 50 patrones menos conocidos, pero ampliamente usados. - Lectura Obligatoria.
* Refactoring to Patterns,, un pedazo de libro, que es como el eslabón que une refactorizaciones y patrones, perfectamente explicado, realmente impresionante como une el libro de Design Patterns, con el de Refactoring  (Fowler) - Lectura Muy Recomendada.
* Implementation Patterns - Un libro que realmente habla más del estilo de código que de patrones, un poco flojo, recomiendo leer Clean Code de Robert C. Martin. - Lectura Medio Recomendada.
* C# 3.0 Design Patterns - Un libro con ejemplos de patrones (GOF) en C# 3.0 sin más. - Lectura Medio Recomendada.
* C# Design Patterns, los GOF con ejemplos en C#, Libro recomendado para los que comienzan con C#.
* xUnit Test Patterns - Si haces pruebas ó TDD es imprescindible. Lectura Muy Recomendada.
* Design Patterns in Ruby - Si eres un salsas, como yo, no esta de más ver como se implementan los GOF en Ruby, muy entretenido. Lectura Pasatiempo.

Por último tengo un librito que aunque parece que esta en chino, no es así, esta en ingles, pero es una edición Design Patterns para China, a mi me gusta para llevarlo en la maleta cuando doy charlas o cursos.


Publicado por Carlos Segura con 3 comment(s)
Archivado en:

YACAMLQT (Yet another CAML query tool) Redux (2)

Continuando con la explicación del código de YACAMLQT.

Habíamos visto la parte relacionada con el Lexer el analizador morfológico. Como es obvio detrás debe haber un analizador sintáctico y semántico el Parser.

El analizador sintáctico y semántico (NParser) se ha implementado siguiendo el patrón interpeter, (seguramente sea uno de los que menos se ven), el objetivo es obtener los distintos Tokens desde el Scanner y montar un árbol sintáctico (AST) este árbol contiene Nodos (ASTNodeBase) y estos nodos representan de manera abstracta y simplificada la estructura sintáctica de la consulta en SQL.

(diagrama NParser)

A la clase NParser se le puede inyectar una factoria (ASTNodeFactoryBase) en función del código que queramos generar, por el momento solo esta implementado el CAML, pero se puede extender sencillamente para generar CAML.Net.

Partiendo de un nodo abstracto (ASTNodeBase) podemos definir las distintas unidades sintácticas, por medio de la herencia. Estos nodos abstractos (heredados de ASTNodeBase ) conforman las distintas expresiones que se usan en el analizador sintáctico y semántico (NParser), para ello se ha definido una clase para cada uno de los Tokens a modo de plantilla (template),  y estas clases son a su vez son las distintas expresiones abstractas, que se usan en  el patrón interpreter implementado en el parser. (NParser).

Todos estos nodos que forman las expresiones abstractas al fin al cabo son plantillas (templates), y podrían a su vez ser clases abstractas, yo opte por una implementarlas como clases normales. Ya que algunos de los nodos son terminales y otros intermedios y no tienen por qué ser heredados, de este modo la factoria base (ASTNodeFactoryBase) usa miembros virtuales parar crear dichos nodos.

(diagrama parcial de ASTNodeBase)

Para crear todos estas expresiones abstractas existe una factoría abstracta (ASTNodeFactoryBase ) a través de la cual creamos los distintos nodos. Como puede verse, para añadir una variante como CAML.Net, solamente hay que añadir las expresiones abstractas heredando de las ya existentes e implementando PreCode() y PostCode().

Todos estos nodos que forman las expresiones abstractas al fin al cabo son plantillas (templates), y podrían a su vez ser clases abstractas, yo opte por una implementarlas como clases normales, debido a que algunos de los nodos son terminales y otros intermedios y no tienen por qué ser heredados, de este modo la factoria base (ASTNodeFactoryBase) usa miembros virtuales parar crear dichos nodos terminales e intermedios.

Después para poder inyectar en el parser dichas expresiones debemos crear una nueva factoría heredada de la factoría base (ASTNodeFactoryBase).

(diagrama ASTNodeFactoryBase)

Para generar CAML lo que he hecho es heredar de cada plantilla ó expresión abstracta definida, una nueva clase que redefine los métodos virtuales PreCode() y PostCode() que son los encargados de sustituir cada nodo del árbol sintáctico en CAML.

Y crear una factoría (ASTNodeCAMLFactory) que se encarga de crear las expresiones.

Publicado por Carlos Segura con no comments
Archivado en: