Angel "Java" Lopez : NHibernate

Generando código con AjGenesis usando archivos de mapeo de NHibernate

lopez — Mon, 23 Nov 2009 09:18:30 GMT

En estos días, estuve trabajando en generar código de clases C#, usando como punto de partida los archivos .hbm, que se usan en NHibernate para especificar el mapeo de clases y tablas de bases relacionales. Como es usual, cuando encaro algo de generación de código uso AjGenesis, mi proyecto open source de generación de código (practico el “dog fooding” :-).

(English version of this post Generating code with AjGenesis using NHibernate hbm files)

Pueden bajar un ejemplo de lo que estoy haciendo de mi Skydrive:

Examples > AjGenesis > NHibernateMappingExample01.zip

(el código en desarrollo está en el trunk, en este change actual, en el directorio examples\NHibernateMappinp:

pero si quieren ir directamente al ejemplo, pueden bajárselo completo desde el Skydrive que mencioné, que incluye el ejecutable de AjGenesis de la versión en desarrollo, no necesitan compilar nada).

Luego de expandir el archivo del ejemplo, tendrán este contenido:

Para crear clases C#, pueden probar de ejecutar los comandos:

GenerateClasses AjFirstExample
GenerateClasses AjTest

Para crear un proyecto .NET con los archivos .cs y .hbm, y una solución, ejecutar:

GenerateProject AjFirstExample
GenerateProject AjTest

Los archivos generados, en ambos casos, quedan en el directorio Build.

Hay dos proyectos ejemplo que son AjFirstExample, con dos mapeos simples, y AjTest, que tiene mapeos más interesantes, con “bags” y relaciones “many to one”.

En el ejemplo, cada proyecto se describe con un simple archivo Project.xml:

<Project Name="AjTest">
</Project>

En cuanto necesite más información, lo agregaré ahí, o en tags meta de los propios archivos de mapeo y configuración.

Este es uno de los archivos de mapeo que sirven de modelo inicial para este ejemplo de generación, en Projects\AjTest\Mappings, Department.hbm:

<?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
  assembly="AjTest.Entities"
  namespace="AjTest.Entities"
  >
  <class name="Department" table="departments">
    <id name="Id" column="Id" type="Int32">
      <generator class="native"/>
    </id>
    <property name="Description" type="String"/>
    <bag name="Employees" lazy="true" inverse="true" cascade="all">


      <key column="IdDepartment"/>
      <one-to-many class="AjTest.Entities.Employee, AjTest.Entities"/>
    </bag>  
  </class>
</hibernate-mapping>

Este es el código generado para este mapeo, Department.generated.cs:

using System;
using System.Collections.Generic;
using Iesi.Collections.Generic;
namespace AjTest.Entities 
{
  public class Department {
    public int Id { get; set; }
    public string Description { get; set; }
    public IList<Employee> Employees { get; set; }
    public Department() 
    {
      this.Employees = new List<Employee>();
    }
  }
}

Veamos el proceso de generación. Este es el contenido de GenerateProject.cmd:

@echo off
set ProjectName=%1%
if "%1%"=="" set ProjectName=AjFirstExample
Bin\AjGenesis.Console.exe Projects\%ProjectName%\Project.xml Tasks\AddMappings.ajg Tasks\BuildCSharp.ajg
xcopy Libraries\*.* Build\%ProjectName%\CSharp\Src\Libraries /Y /Q

La línea más importante es la que invoca a AjGenesis.Console.exe. El contenido de Project.xml se carga en memoria. La tarea AddMapping.ajg se carga y ejecuta (está escrita en un lenguaje dinámico, afectuosamente llamado AjBasic), y luego, se procesa la tarea BuildCSharp.ajg. Veamos el código de AddMapping.ajg:

' Add mappings from directory if not specified in Project model
Include("Utilities/Utilities.tpl")
if not Project.Mappings then
  Project.Mappings = CreateList()
  
  di = new System.IO.DirectoryInfo("Projects/${Project.Name}/Mappings")
  
  for each fi in di.GetFiles("*.hbm.xml")
    filename = fi.Name
    Project.Mappings.Add(filename.Substring(0, filename.Length - 8))
  end for
end if

Encuentra y agrega los nombres de los archivos de mapeo contenidos en el directorio de Mapping, dentro del proyecto (noten que se pueden usar clases y objetos del framework .NET). Una tarea más interesante es la GenerateCSharp.ajg. Primero, carga la dll de NHibernate, para usar más adelante su parser de archivos hbm:

include "Utilities/Utilities.tpl"
include "Utilities/FileUtilities.tpl"
include "Utilities/TypeUtilities.tpl"
Include("Utilities/NHibernateUtilities.tpl")
include "Templates/CSharp/UtilitiesCs.tpl"
include "Templates/CSharp/CSharpFunctions.tpl"
AssemblyManager.LoadFrom("Libraries/NHibernate.dll")
parser = new NHibernate.Cfg.MappingSchema.MappingDocumentParser()

Crea objetos dinámicos, donde coloca información de la solución y el proyecto a crear:

if not Project.BuildDir then
  Project.BuildDir = "Build/${Project.Name}/CSharp"
end if
message "Creating Directories..."
FileManager.CreateDirectory(Project.BuildDir)
FileManager.CreateDirectory("${Project.BuildDir}/Sql")
FileManager.CreateDirectory("${Project.BuildDir}/Src")
FileManager.CreateDirectory("${Project.BuildDir}/Src/Libraries")
message "Defining Solution and Projects..."
Project.Solution = CreateObject()
Project.Solution.Guid = "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC"
Project.Solution.Projects = CreateList()
message "Defining Entities Project..."
PrjEntities = CreateObject()
PrjEntities.Includes = CreateList()
PrjEntities.Guid = CreateGuid()
PrjEntities.COMGuid = CreateGuid()
Project.Solution.Projects.Add(PrjEntities)
Project.Entities = CreateList()

Ahora, itera sobre cada archivo hbm, lo lee usando el parser del propio NHibernate, toma información sobre las clases a generar:

for each MappingName in Project.Mappings
  filename = "Projects/${Project.Name}/Mappings/${MappingName}.hbm.xml"
  mapping = parser.Parse(OpenAsStream(filename))
    
  for each hbmclass in mapping.Items where IsType(hbmclass, "HbmClass")
    Entity = CreateObject()
    
    Project.Entities.Add(Entity)
  
    Entity.ClassName = hbmclass.name
    Entity.Namespace = mapping.namespace
    
    ' Namespace as default project name for Entities Project
    if not PrjEntities.Name then
      PrjEntities.Name = mapping.namespace
      PrjEntities.Directory = "${Project.BuildDir}/Src/${PrjEntities.Name}"
      FileManager.CreateDirectory(PrjEntities.Directory)
    end if
    
    Entity.Properties = CreateList()
    
    if hbmclass.Id then
      Property = CreateObject()
      Property.Name = hbmclass.Id.name
      Property.Type = HbmTypeToCSharp(hbmclass.Id.type1, Entity.Namespace)
      Entity.Properties.Add(Property)
    end if
    
    for each item in hbmclass.Items
      if IsType(item, "HbmProperty") then
        Property = CreateObject()
        Property.Name = item.name
        Property.Type = HbmTypeToCSharp(item.type1, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      
      if IsType(item, "HbmManyToOne") then
        Property = CreateObject()
        Property.Name = item.name
        Property.Type = HbmTypeToCSharp(item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      if IsType(item, "HbmSet") then
        Property = CreateObject()
        Property.Name = item.name
        Property.IsSet = true
        Property.Type = HbmTypeToCSharp(item.Item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      if IsType(item, "HbmBag") then
        Property = CreateObject()
        Property.Name = item.name
        Property.IsList = true
        Property.Type = HbmTypeToCSharp(item.Item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
    end for    
  end for
end for

Pueden extender esta capacidades, procesando más tags (debería escribir un ejemplo usando los tags meta que puede contener el hbm; ya utilitarios de Java, como el venerable XDocLet, usaban esos tags para ayudarse en la generación de código, en Hibernate), y detectar más formas de mapeo de NHibernate. Ahora, pasa a la generación de código:

for each Entity in Project.Entities
  TransformerManager.Transform("Templates/CSharp/Entity.tpl", "${PrjEntities.Directory}/${Entity.ClassName}.generated.cs", Environment)
  PrjEntities.Includes.Add(CreateFileCs("${Entity.ClassName}.generated"))
end for

La tarea genera los archivos .cs, y también crea un archivo de solución y otro de proyecto C#, copiando y embebiendo los archivos de mapeo originales:

for each MappingName in Project.Mappings
  filename = "Projects/${Project.Name}/Mappings/${MappingName}.hbm.xml"
  targetfilename = "${PrjEntities.Directory}/${MappingName}.hbm.xml"
  System.IO.File.Copy(filename, targetfilename, true)
  PrjEntities.Includes.Add(CreateFileType(MappingName,"hbm.xml"))
end for
for each CsProject in Project.Solution.Projects where CsProject.ProjectType<>"Web"
  FileManager.CreateDirectory(CsProject.Directory)
  FileManager.CreateDirectory(CsProject.Directory & "/Properties")
  TransformerManager.Transform("Templates/CSharp/CsProject.tpl", "${CsProject.Directory}/${CsProject.Name}.csproj", Environment)
  TransformerManager.Transform("Templates/CSharp/AssemblyInfoCs.tpl", "${CsProject.Directory}/Properties/AssemblyInfo.cs", Environment)
end for
TransformerManager.Transform("Templates/Solution.tpl", "${Project.BuildDir}/Src/${Project.Name}.sln", Environment)

Esta es la solución generada:

Próximos pasos

Debería trabajar en algunos puntos:

- Generar una solución más completa, como en otros ejemplos de AjGenesis (con un proyecto de infraestructura, un proyecto de Service Layer o similar, una presentación web, etc…).

- Soportar más opciones de mapeo de NHibernate.

- Usar los tags meta.

Por ahora, pueden jugar con este ejemplo. Pueden cambiar los templates para generar más artefactos, por ejemplo, código VB.NET.

Gracias a @fabiomaulo por avisarmr de las capacidades públicas de parser de hbm dentro de NHibernate!

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

NHibernate en SQL Azure

lopez — Tue, 03 Nov 2009 16:12:26 GMT

El viernes pasado, estuve hablando con Fabio Maulo (@fabiomaulo) de varios temas: de desarrollo de software, enseñanza de la programación, y por supuesto, sobre NHibernate. Ambos vivimos en Buenos Aires, Argentina, y fue un placer hablar con él, como siempre. Yo sigo a Fabio en Twitter, y soy un subscripto a su blog. Fabio ha estado colaborando con el proyecto NHibernate desde hace años, y es un reconocido desarrollador en la comunidad .NET.

Me contó detalles de un sitio que construyó con un equipo, usando NHibernate. Lo interesate es que corre sobre SQL Azure. Pueden verlo en línea (es un sitio mexicano):

http://salondetokio.autocosmos.com.mx/

Fabio y su equipo trabajaron duro para armar este sitio, en menos de mes (estoy esperando que el equipo de Fabio comente más detalles en posts, por ahora, puedo hablar sobre lo que se conoce públicamente).

Curiosamente, el sitio está ejecutando sobre WebForms, pero sin usar ViewState, y sin tener un tag de Form en varios de los tags Body de las páginas que he examinado. Espero que Maulo y su equipo escriban explicando los detalles de implementación. El código está basado en el patrón Model View Presenter, ha sido escrito con tests automáticos, mocks, stubs, comenzando desde cerca de la presentación, hasta llegar a la persistencia. ¡Vamos Fabio! ¡Estamos esperando detalles sobre el proceso seguido y las decisiones de arquitectura! :-)

Más información sobre NHiberante y SQL Azure:

NHibernate on the cloud: SQL Azure Tests de NHibernate sobre SQL Azure, según Ayende

Quick news NHibernate with SQL Azure Los primeros pasos de Fabio en el tema: “All work… even the SchemaExport.” !!

NHibernate dialect for SQL Azure Ajustes para el SchemaExport

Estoy coleccionando enlaces sobre NHibernate y Azure en:

http://delicious.com/ajlopez/nhibernate+azure

Hay una excelente serie de posts de Brad Adams, explicando Azure en general, SQL Azure, NHibernate, Silverlight, RIA .NET Services, y más:

Index for Business Apps example for Silverligth 3 RTM and .NET RIA Services July Update

Relacionado a NHibernate y Azure, en esa serie:

Part 20: NHibernate
Part 23: Azure

¿Conocen otro proyecto que use NHibernate en “el cloud”?

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Primer ejemplo con NHibernate 2.x

lopez — Thu, 04 Jun 2009 09:17:00 GMT

Estuve trabajando creando una solución .NET que contiene un ejemplo mínimo de NHibernate 2.x. Estoy usando la distribución binaria NHibernate GA 2.0.1, siguiendo las instrucciones del manual de referencia.

Pueden bajarse el código fuente de la solución de mi Skydrive:

NHibernateExample1.zip

Estuve usando la documentación en línea de

http://nhforge.org/doc/nh/en/

y armé el mismo manual en formato .pdf, usando comandos del trunk de SVN:

https://nhibernate.svn.sourceforge.net/svnroot/nhibernate

Si quieren, pueden bajar el manual en .pdf de este enlace:

nhibernate-reference.pdf

La solución contiene dos proyectos: una librería de clases, y una aplicación de consola:

El dominio sólo contiene una clase, Cat (estoy siguiendo el primer ejemplo que se describe en la documentación):

namespace NHibernateExample1.Domain
{
    public class Cat
    {
        private string id;
        private string name;
        private char sex;
        private float weight;

        public Cat()
        {
        }
        public virtual string Id
        {
            get { return id; }
            set { id = value; }
        }

        public virtual string Name
        {
            get { return name; }
            set { name = value; }
        }

        public virtual char Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        public virtual float Weight
        {
            get { return weight; }
            set { weight = value; }
        }
    }
}

Hay un recurso embebido que describe el mapeo Cat.hbm.xml:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
namespace="NHibernateExample1.Domain" assembly="NHibernateExample1.Domain">
  <class name="Cat" table="Cats">
    <!-- A 32 hex character is our surrogate key. It's automatically
generated by NHibernate with the UUID pattern. -->
    <id name="Id">
      <column name="CatId" sql-type="char(32)" not-null="true"/>
      <generator class="uuid.hex" />
    </id>
    <!-- A cat has to have a name, but it shouldn' be too long. -->
    <property name="Name">
      <column name="Name" length="16" not-null="true" />
    </property>
    <property name="Sex" />
    <property name="Weight" />
  </class>
</hibernate-mapping>

Hay un ExecuteAll.cmd en el directorio Sql, que crea la base de datos a usar (pueden darle como parámetro el servidor de MS SQL Server a usar, .\SQLEXPRESS es el valor asumido):

La aplicación de consola es simple: configura NHibernate, obtiene una sesión, inserta nuevos objetos en una transacción, ejecuta una consulta, y lista el resultado:

        static void Main(string[] args)
        {
            ISessionFactory sessionFactory = new Configuration().Configure().BuildSessionFactory();

            ISession session = sessionFactory.OpenSession();
            ITransaction tx = session.BeginTransaction();

            Cat cat;

            cat = new Cat() { Name = "Moe", Sex = 'M', Weight = 9.0f };

            session.Save(cat);

            cat = new Cat() { Name = "Larry", Sex = 'M', Weight = 8.5f };

            session.Save(cat);

            cat = new Cat() { Name = "Sue", Sex = 'F', Weight = 7.5f };

            session.Save(cat);

            tx.Commit();

            IQuery query = session.CreateQuery("select c from Cat as c where c.Sex = :sex");

            query.SetCharacter("sex", 'M');

            foreach (Cat kitty in query.Enumerable())
                System.Console.Out.WriteLine("Male Cat: " + kitty.Name);

            session.Close();

            System.Console.ReadLine();
        }

Ejecutando la aplicación de consola se inserta en la base estos datos:

El ejemplo es simple. Ahora que está funcionando con NHibernate 2.0, pienso actualizar mis templates de AjGenesis para usar esa versión.

No dejen de visitar el sitio de comunidad de NHibernate, para conseguir más información:

http://nhforge.org

Si tienen dudas sobre NHibernate, pueden preguntar en el grupo en español:

NHibernate-Hispano

Nos leemos!

Angel “Java” Lopez

http://www.ajlopez.com
http://twitter.com/ajlopez

Enlaces y noticias

lopez — Thu, 24 Jul 2008 11:48:44 GMT

Hay varios temas de los que quisiera bloguear más en detalle. Pero vaya hoy una lista de enlaces y comentarios cortos:

Primero de todo, tenemos nuevos Microsoft MVPs por aquí en Argentina, felicitaciones a Rodolfo Finochietti, Pablo Galiano, y al pibe Matías Woloski. El bueno de Finochietti visita de vez en cuando este blog, y deja comentarios, por ejemplo, sobre programación funcional y el lenguaje Cat. Tenemos varios intereses en común, como el estudio de lenguajes, compiladores, y compartimos la afición por la historia de las matemáticas.

Si se interesan en Smalltalk, es interesante The Smalltalk programming language.

Gracias al bueno de Martin Salias, que me avisó de este texto en la web The Early History of Smalltalk de Alan Kay (yo había anunciado una versión en PDF en La historia de Smalltalk). Es un "DEBESERLEIDO" por todo aquel que esté realmente interesado en la programación. Uno debe conocer la historia de las ideas, para realmente entender la situación actual tanto de ideas, como de tecnologías, y para tener un "grasp" de lo que podría venir.

Modu: gracias al twitter de @parancibia, vean este mobile modular. Muy interesante el concepto.

De vez en cuando, Microsoft Directions publica un artículo público. Lean Software Plus Services and Developers. ¿The next big thing?

Dentro del proyecto NHContrib, de herramientas para NHibernate, existe NHibernate.LINQ, que permite usar LINQ sobre NHibernate. Vean ahora lo que se hizo con Silverligh en Silverlight 2 + NHibernate.LINQ == Sweet y el ejemplo de nhibernate con Northwind

Para aprender NHibernate NHibernate - Relational Persistence for Idiomatic .NET. Si quieren contribuir al proyecto hibernate.org - Getting Started with the NHibernate Source Code. Si tienen dudas, ver la lista de NHibernate Hispano.

Siguiendo con LINQ, leo cómo usar un DataContext en memoria, esta vez desde ASP.NET MVC, en ASP.NET MVC Tip #21 – Fake the Data Context

Las aventuras de Scott Hanselman para agregar un OpenSearch en sus páginas: Adding OpenSearch to your website and getting in the Browser's Search Box

Steve Clayton está en Software + Services en Microsoft. Lean su encuentro con Ray Ozzie, no puede decir todo, pero S+S se viene cada vez más. El tiempo dirá qué será eso.

No llegué a tiempo para anunciarla. Diego Jancic realizó una encuesta en línea sobre cómo programamos. Vean los resultados en el blog de Darío Quintana.

El Composite Application Guidance para WPF tiene su nueva página en MSDN.

Jeff Atwood tiene algunas ideas interesantes y discutibles sobre no normalizar base de datos.

.NET Terrarium está de vuelta!

Me interesó el proyecto Jackrabbit, tengo que estudiar más en detalle la especificación Content Repository API de la JSR-170.

Twitter adquiriendo a Summize.

Y hay que visitar y usar 10 herramientas para un tech.

Nuevo Blog de la comunidad MSDN en español. Gracias a Miguel Angel Saez por el aviso.

Si alguien necesita acá está: Implementing Finite State Machines with Physhun and Spring (en Java)

Cada vez más lenguajes dinámicos sobre máquinas virtuales, ver Java 6: Using Python via the new Scripting Engine.

Interesante código y artículo, sobre un tema que se necesita conocer: Single Sign-on in ASP.NET and Other Platforms

Para entender la historia de MVC: The Model-View-Controller, Its past and present

Más sobre Model-View-Controller, Model-View-Presenter, y Presentation-Abstraction-Control en Interactive Application Architecture Patterns.

MVC en ASP.NET en ASP.NET MVC - The Official Microsoft ASP.NET Site

Una interesante comparación de David Hayden ASP.NET MVC Framework Compared To Web Client Software Factory ( WCSF )

¿Necesitan un manejar un proyecto de software? No lo uso, vería el open source Trac Project, via web en Java (gracias a J. Franco, por este enlace). Al parecer, trabaja con Subversion.

¿Necesitan open source en Java? De todo en http://java-source.net/.

Off topic total: mi mejor post hasta ahora del 2008, con gráfica incluida, en Posmopolitan.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez
http://friendfeed.com/ajlopez

Libro Foundation of Programming, listo para bajar

lopez — Wed, 25 Jun 2008 15:48:54 GMT

Gracias a Cladio M.E. Bastos Iorio de http://www.blumer.com.ar me entero de la aparición de este libro. Claudio posteó la información en una lista pública del MUG de Argentina (http://www.mug.org.ar/ ):

Foundations of Programming Ebook

I'm excitted to finally release the official, and completely free, Foundations of Programming EBook. This essentially contains all 9 Foundation parts including a conclusion and some typical book fluff (table of content, acknowledgement and so on). A number of spelling errors were corrected, along with some small technical changes and clarifications - largely based on feedback, so thanks for everyone who provided it! Otherwise it's exactly the same as what's been posted here over the past several months.
Download it from http://codebetter.com/files/folders/codebetter_downloads/entry179694.aspx

If the above link fails, you can also get it from http://www.openmymind.net/FoundationsOfProgramming.pdf

Acabo de leer el índice, y de leer algunos capítulos rápidamente. Es muy interesante los temas que toca, y parece bien encarados. El bueno de Karl Seguin ha hecho un magnífico trabajo, colocando en un solo libro temas que nos tocan en el desarrollo de software de todos los días. Si bien está algo orientado a .NET, es totalmente aprovechable en otras tecnologías, como Java. El texto había ido apareciendo en los últimos meses, en forma de posts, y revisado por colegas, en general dentro del movimiento ALT.NET, así que el trabajo de Seguin se ha enriquecido con los comentarios de la comunidad de desarrollo.

Sobre el autor

Karl Seguin is a developer at Fuel Industries, a former Microsoft MVP, a member of the influential CodeBetter.com community and an editor for DotNetSlackers. He has written numerous articles and is an active member of various Microsoft public newsgroups. He lives in Ottawa, Ontario Canada.
His personal webpage is: http://www.openmymind.net/
His blog, along with that of a number of distinguished professionals, is located at: http://www.codebetter.com/

Enumero algunos temas tratados:

- El movimiento ALT.NET, enumerando y desarrollando sus pilares, algo confrontados con la visión MSDN

- Domain-Driven Design, explicando los términos, y justamente, explicando cuándo usarlo y cuándo no, cuál es el contraste con una aproximación Data-Centric.

- Persistencia, algo con lo que lidiamos en prácticamente cada proyecto.

- Dependency Injection, una de las mejores técnicas inventadas, desde que alguien dijo que el pan tenía que venir en rebanadas.

- Unit Testing, indispensable en el bolso de la desarrolladora y en el bolsillo del caballero desarrollador. Hay días en los que pienso que hasta el Hello World de Kernighan y Ritchie debería tener su Unit Test.

- Object Relational Mappers, todo un capítulo explicando la idea y algunas implementaciones, usando NHibernate.

- Manejo de memoria, un back to basics que veo necesario, como comento en mis cursos.

- Excepciones, otro back to basics que se debe explicar.

- Proxy, tengo que ver en detalle este capítulo, para ver hasta dónde llega la idea del autor.

El libro también viene acompañado de código, con ejemplos de los temas tratados, por ejemplo, las formas de usar NHibernate, documentando sus características. Lo pueden bajar desde:

http://openmymind.net/CodeBetter.Foundations.zip

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

"Ver la luz" con generación de código y AjGenesis

lopez — Tue, 10 Jun 2008 14:02:59 GMT

Ayer dí una charla gratuita sobre generación de código, usando AjGenesis. Espero haber transmitido la idea de que es más que generación de código, y que va más allá de la tecnología actual.

Quisiera enumerar algunos posts relacionados con el tema, y comentarlos, así como enumerar enlaces y recursos.

Posts sobre generación de código

Sobre la generación de código

Este es el primer post a leer. Vemos ahí que el cambio de tecnología es una constante en la historia de desarrollo de software, y que no se ve en el horizonte una unificación de nada, ni de lenguajes ni de plataformas. Cada año que pasa, sabemos más de hacer sistemas, pero curiosamente, cada sistema nuevo necesita más codigo que el anterior, en general. Aún usando tecnologías que nos alivian el trabajo, por ejemplo, algún ORM (Object Relational Mapper), si la tecnología triunfa, el propio mercado nos lleva a hacer sistemas más complejos y grandes, y lo que ahorramos en código a escribir, luego lo perdemos en la mayor complejidad de lo sistemas que tenemos a nuestro alcance construir.

También se enumeran otras alternativas a la generación de código, y sus problemas. Las herramientas CASE son muy rígidas, o generales o abarcativas, así como UML y otras iniciativas. Lo que necesitamos son modelos específicos de nuestro dominio, y poder generar lo que querramos, de la forma que nos convenga. De ahí la necesidad de contar con un generador de código que no esté orientado a una tecnología a generar en particular, que sea de código abierto, y que genere lo que nosotros le indicamos, no lo que los autores de la herramienta quieren o pensaron inicialmente.

El usar frameworks propietarios, quedarse en una sola tecnología, tratar de generar todo en runtime apelando a metadata, o generar código desde XML aplicando transformaciones XSLT, son alternativas que creo que son inferiores o más complejas, como se explica en ese post.

Generando Código- Hello World con AjGenesis

Esta es la "prueba ácida" de todo generador de código. Si una herramienta de ese tipo no nos ayuda a crear programas "Hola mundo", con variantes, en distintas tecnologías, entonces no es lo bastante flexible. AjGenesis hace hincapié en la flexibilidad, la adaptibilidad a lo que Uds quieran producir, sin atarlos a una forma o metadata en particular.

Generando aplicaciones con AjGenesis

Un post algo viejo, pero que muestra cómo se pueden generar aplicaciones no triviales con esta herramienta.

AjGenesis- Modelo generado desde los assemblies
AjGenesis- Modelo desde la Base de Datos

Posts sobre cómo el modelo puede partir de otras fuentes, cualquiera que Uds. vean que sea conveniente. Luego, la propia herramienta puede mejorar, completar el modelo, hacer inferencias, o Uds. mismos completarlos, por ejemplo, si el modelo de base de datos no es lo bastante rico para darnos algo de semántica sobre el sistema que tenemos entre manos.

Generando código para NHibernate (Parte 3)
Generando código para NHibernate (Parte 2)
Generando código para NHibernate (Parte 1)

Para ver que pueden usar AjGenesis para facilitar el desarrollo usando alguna librería reconocida por la comunidad, pueden leer esta serie de enlaces, donde gracias a una idea de Omar del valle Rodríguez, se desarrollaron templates para usar NHibernate, y generar hasta una capa de presentación web para probar lo generado.

Hacia el AjGenesis Recipes

Es un trabajo en progreso, para incorporar interacción con el usuario durante el proceso de generación de código.

Usando AjGenesis y NAnt

Explicación y enlaces para usar AjGenesis desde NAnt. Si alguien necesita una interfaz gráfica NAnt-GUI, pueden bajarla desde NAnt-GUI (preparado por Carlos Marcelo Santos, del grupo de generación de código)

Genesis Studio- una IDE para AjGenesis

No todo lo tienen que hacer desde la línea de comando, o desde el NAnt/NAnt-GUI. El bueno de Jonathan Cisneros desarrolló esta herramienta WinForm, con sintaxis de color y muchas mejoras en la experiencia de usuario, que pueden bajar desde:

http://www.codeplex.com/ajgenesisstudio

Preservando código en AjGenesis

Si necesitan generar código, pero luego modificarlo, pueden usar algunas capacidades de AjGenesis para delimitar qué parte regenerar y cuales conservan.

Code Generation as a Service

La última adición al AjGenesis: ahora pueden generar código usando una interfaz web. Esto permite que ya sea en Internet, o desde la intranet de su empresa, puedan generar código controlado, que cumpla con los estándares que se hayan adoptado.

Más posts sobre AjGenesis en

AjGenesis

Si necesitan pasarle información a alguien que no maneja el español, pueden probar con mis artículos en "Anglish" (Angel's English):

http://ajlopez.wordpress.com/category/ajgenesis

Enlaces

EL sitio sobre generación de código es

http://www.codegeneration.net

Ahí encontraran comentarios, herramientas, preguntas frecuentes sobre generación de código en general. Tienen una base de datos de herramientas publicadas. Hay enlaces sobre generación de código para distintas tecnologías, como Java, .NET, PHP y también temas de MDA (Model-Driven Architecture).

Otros enlaces que tratamos en las charlas son:

CodeSmith Tools

MyGeneration Software

AndroMDA.org - Home

Mantengo todo tipo de enlaces relativos a generación de código en

http://del.icio.us/ajlopez/codegeneration

Lista de correo sobre generación de código

Existe un Google Group que se puede consultar por email, en español, dedicado a la generación de código. Ahí, además de otros temas, se trata de generación de código con AjGenesis, la generación de templates. En los archivos del grupo se publican ejemplos armados por los miembros.

Pueden ver los mensajes y suscribirse, en:

http://groups.google.com/group/codegeneration

Conclusión

Espero que quede claro que lo importante es usar generación de código como solución pragmática, pero basado en la abstracción de un modelo. Hacer el ejercicio de abstracción de generar un modelo adecuado para lo que necesitemos, es un "must" que me parece el primer paso para separarnos de los problemas de cambios en las tecnologías, herramientas y plataformas.

Luego, el modelo debe ser de libre definición. Y el texto o código generado, también: debe ser el tipo de texto o código que hubiéramos generado nosotros mismos. Finalmente, la herramienta de generación de código tiene que estar disponible en código totalmente abierto, para que se pueda extender, entender o usar de la forma que querramos.

Tengo que escribir más sobre la importancia del modelo, y que pueden hacer el suyo propio: no hay modelo fijo, pueden partir desde la base de datos, desde los archivos XML de los ejemplos, o desde donde quieran. También tengo que escribir sobre la posibilidad de hacer modelos que se deriven de otros modelos. Y escribir haciendo énfasis en que lo que construimos, en realidad, es un sistema experto. De ahí, que desde el principio, incorporé un lenguaje de programación que puede tomar decisiones, completar y modificar el modelo.

Como ven, con AjGenesis, ¡sky is the limit! :-)

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Seminarios gratuitos de NHibernate, en Buenos Aires

lopez — Thu, 31 Jan 2008 07:14:20 GMT

El mes de febrero, se viene interesante. El Microsoft User Group de Argentina presenta a Fabio Maulo y Darío Quintana, activos miembros del equipo de desarrollo del proyecto de código abierto NHibernate, en dos charlas, miércoles 20 y jueves 21 de Febrero, de 18:30 a 21:30hs.

Veremos a Fabio y Darío tratando los temas:

SEMINARIO 20/02/08 "NHibernate: ORM Persistence Framework"

- Quick Start
- Entorno de test de entities

- Manejo de Session de NHibernate: Qué cosas hacer y qué no.
- Parent-Child
- Overview Lazy-Loading

- Ejemplo de como cambiar base de datos usando los ejemplos generado
en toda la charla.
- Overview NHibernate.Validator

SEMINARIO 21/02/08 "NHibernate Advanced"

- Introducción a NHibernate
- Manejo de Sesiones.

- Conceptos y ejemplos: EntityName, SQL nativa para CRUD, Transformers, StoredProcedure, Named-Queries, Event-Listeners, Filters, MultiQuery, StatelessSession, UserType, UserCollectionType, Batch-size entre otros.
- Queries: HQL, Criteria, SQL Nativo.

- NHibernate.Shards: Estado del arte

- Tunning

Detalle, inscripción, datos adicionales, en la página del MUG:

Seminarios Gratuitos de NHibernate

Como siempre, la referencia para consultas sobre NHibernate, en español, es:

NHibernate-Hispano

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Generando código para NHibernate (Parte 3)

lopez — Mon, 29 Oct 2007 09:17:00 GMT

Siguiendo con la serie

Generando código para NHibernate (Parte 1)
Generando código para NHibernate (Parte 2)

del ejemplo de Omar del valle Rodriguez, tengo una nueva versión del ejemplo, que genera aplicaciones con AjGenesis. Gracias desde acá, a las sugerencias de Omar, y de Fabio Maulo. He incorporado algunas características, como:

- Uso de NHibernate 1.2

- Manejo de mapeo de subclases en .hbm por separado

- Propiedades virtuales en las entidades

- Dos nuevas aplicaciones generadas

Pueden bajar el ejemplo AjOmar Versión 1.1 (es el archivo AjOmar-v1.1.zip) desde la página de ejemplos de AjGenesis.

El modelo

Como siempre, la idea de AjGenesis es basarse en un modelo libre, donde uno especifica lo que le interesa modelar. En el caso de este ejemplo, se modelan entidades, y a partir de esa información se generan aplicaciones completas. El modelo prácticamente no cambió desde la anterior versión (ver Parte 2), en el archivo Projects/AjOmar/Project.xml:

<Project>
    <Name>AjOmar</Name>
    <Description>Example AjOmar for (N)Hibernate</Description>
    <Prefix>AjOm</Prefix>
    <Domain>com.ajomar</Domain>
    <CompanyName>ajomar</CompanyName>
    <Model>
        <Entities>
            <Entity Source="Entities/Client.xml"/>
            <Entity Source="Entities/Company.xml"/>
            <Entity Source="Entities/User.xml"/>
        </Entities>
    </Model>
</Project>

Como había pedido Omar, Company y User heredan de Client. En la base de datos se usan tres tablas, y el NHibernate hace la magia del mapeo en este dominio con entidades relacionadas por herencia.

Como antes, también se especifican los elementos de tecnología, como la base de datos a usar, el usuario y contraseña a usar en los strings de conección, y otros detalles. Esto permite cambiar la tecnología, sin cambiar el modelo de arriba. Un ejemplo en el archivo Projects/AjOmar/Technologies/VbNet2Nh.xml:

<Technology>
    <Programming>
        <Dialect>VbNet2Nh</Dialect>
    </Programming>
    <Database>
        <Dialect>MsSql</Dialect>
        <Name>AjOmar</Name>
        <Username>sa</Username>
        <Prefix>ajom_</Prefix>
        <Host>(local)</Host>
    </Database>
    <NHibernate>
        <Dialect>NHibernate.Dialect.MsSql2000Dialect</Dialect>
    </NHibernate>
</Technology>

Deberá adaptar este archivo si necesita ajustar esos datos.

Siguiendo algunas recomendaciones de Fabio Maulo, ahora hay un .hbm por entidad. Ejemplo generado en Build/AjOmar/VbNet2Nh/Src/AjOmar.Data/Company.hbm.xml:

<?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
    assembly="AjOmar.Entities"
    namespace="AjOmar.Entities"
    >
    <joined-subclass name="Company" table="ajom_companies" extends="Client">
        <key column="Id" />
        <property name="CompanyName" type="String"/>
        <property name="ContactName" type="String"/>
    </joined-subclass>
</hibernate-mapping>

Las aplicaciones

Se pueden generar aplicaciones completas, con proyectos y solución web. La generación se invoca con comando de línea, como se explica en la Parte 2. Hay que agregar el directorio bin del AjGenesis en el path de ejecución para que funcionen.

Ahora están habilitados cuatro generaciones de soluciones:

GenerateProject AjOmar VbNet2Nh
GenerateProject AjOmar CSharp2Nh
GenerateProject AjOmar VbNet2DDDNh
GenerateProject AjOmar CSharp2DDDNh

Los dos primeros generan aplicaciones VB.NET y C Sharp, con ASP.NET 2.x, y acceso a datos usando DAOs que usan NHibernate.

Los dos nuevos comandos generan aplicaciones con VB.NET y C Sharp, que utilizan algunas ideas de Domain-Driven Design.

Generando DDD

Las nuevas soluciones generadas, tienen varios proyectos de librerías de clases:

AjNHibernate: contiene las clases para el manejo de las llamadas al NHibernate, como configuración, factoría y obtención de sesiones.
AjOmar.Domain: contiene las Entities, Services, y Repositories, a la Evans. No hay conceptos de Value Objects, o Aggregates. Los servicios se llaman Manager, para distinguirlos de la fachada de servicio que uso en Application.
AjOmar.Application: la capa que coordina las llamadas al Dominio, desde la presentación.

Y como antes, hay una aplicación web AjOmar.WebClient.

Próximos pasos

Tengo que generar aplicaciones similares para Hibernate, Java, y MySql. La idea es que sirva como prueba de concepto: desde un mismo modelo, se pueden generar aplicaciones implementadas con distintas tecnologías.

Habrá que estudiar e implementar el manejo de nulos, restricciones por tamaño de campo, y mejorar la apariencia de las aplicaciones generadas.

Hay que mejorar (y probar) el manejo de relaciones uno a varios, o varios a uno. Lo tengo implementado en los ejemplos AjGenesisExamples3, pero debería pasar ese código de plantillas y adaptarlo para este ejemplo.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Generando código para NHibernate (Parte 2)

lopez — Mon, 24 Sep 2007 23:12:30 GMT

Gracias a una iniciativa del bueno de Omar del valle Rodriguez comencé a escribir un ejemplo con AjGenesis, para generar código .NET que use NHibernate (ver Generando código para NHibernate (Parte 1)). Ya tenía ejemplos con y sin NHibernate (ver ....) pero esta vez, Omar pidió un modelo con herencia. Pueden descargar esta primera versión como AjOmar-v1.0.zip desde los ejemplos del proyecto en Codeplex.

Usé la versión 0.5 de AjGenesis, a descargar desde CodePlex. Si Ud. tiene la versión 0.4.3, debería funcionar sobre este ejemplo, pero no la he probado.

El modelo

Ahora tengo una primera versión de lo pedido por Omar. El "leit-motiv" del AjGenesis, es basarse en un modelo definible libremente, y desde ahí, ir generando código, scripts de base de datos, artefactos de textos, archivos de solución, proyectos, lo que uno quiera.

En el modelo Projects\AjOmar\Project.xml he definido:

<Project>
    <Name>AjOmar</Name>
    <Description>Example AjOmar for (N)Hibernate</Description>
    <Prefix>AjOm</Prefix>
    <Domain>com.ajomar</Domain>
    <CompanyName>ajomar</CompanyName>
    <Model>
        <Entities>
            <Entity Source="Entities/Client.xml"/>
            <Entity Source="Entities/Company.xml"/>
            <Entity Source="Entities/User.xml"/>
        </Entities>
    </Model>
</Project>

Para entender algo más sobre el modelo y la generación, ver Hello World con AjGenesis.

En el modelo coloqué tres entidades: Client, Company, User, que es lo que pedía Omar. En Client, tengo:

<Entity>
    <Name>Client</Name>
    <Description>Client Entity</Description>
    <SetName>Clients</SetName>
    <Descriptor>Client</Descriptor>
    <SetDescriptor>Clients</SetDescriptor>
    <SqlTable>clients</SqlTable>
    
    <Properties>
        <Property>
            <Name>Id</Name>
            <Type>Id</Type>
        </Property>

        <Property>
            <Name>PhysicalAddress</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>

        <Property>
            <Name>ContactEmail</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>

        <Property>
            <Name>RegisterDate</Name>
            <Type>DateTime</Type>
            <SqlType>datetime</SqlType>
        </Property>

        <Property>
            <Name>Active</Name>
            <Type>Boolean</Type>
            <SqlType>bit</SqlType>
        </Property>
    </Properties>
</Entity>

Los campos son los pedidos por Omar, pero todavía con tipos y nombres SQL que elegí yo. Client es la clase madre de Company y de User. En el Company.xml tenemos:

<Entity>
    <Name>Company</Name>
    <Description>Company Entity</Description>
    <SetName>Companies</SetName>
    <Descriptor>Company</Descriptor>
    <SetDescriptor>Companies</SetDescriptor>
    <SqlTable>companies</SqlTable>
    <Inherits>Client</Inherits>
    
    <Properties>
        <Property>
            <Name>CompanyName</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>

        <Property>
            <Name>ContactName</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>
    </Properties>
</Entity>

Para los que vieron anteriores ejemplos, lo nuevo es el <Inherits>Client</Inherits>. Esto indica que esta entidad "hereda" de la entidad Client, en el dominio a generar. Lo mismo puse en User.xml:

<Entity>
    <Name>User</Name>
    <Description>User Entity</Description>
    <SetName>Users</SetName>
    <Descriptor>User</Descriptor>
    <SetDescriptor>Users</SetDescriptor>
    <SqlTable>users</SqlTable>
    <Inherits>Client</Inherits>
    
    <Properties>
        <Property>
            <Name>FirstName</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>

        <Property>
            <Name>LastName</Name>
            <Type>Text</Type>
            <SqlType>varchar(200)</SqlType>
        </Property>
    </Properties>
</Entity>

En el subdirectorio Projects\AjOmar\Technologies, encontramos los archivos CSharp2Nh.xml y VbNet2Nh.xml. Veamos el primero:

<Technology>
    <Programming>
        <Dialect>CSharp2Nh</Dialect>
    </Programming>
    <Database>
        <Dialect>MsSql</Dialect>
        <Name>AjOmar</Name>
        <Username>sa</Username>
        <Prefix>ajom_</Prefix>
        <Host>(local)</Host>
    </Database>
    <NHibernate>
        <Dialect>NHibernate.Dialect.MsSql2000Dialect</Dialect>
    </NHibernate>
</Technology>

Vean que ahí se establece el usuario y contraseña para usar contra un SQL Server. Si quieren, lo modifican acá. Sino, como alternativa, pueden luego modificar el web.config de la solución generada. El ejemplo también instala base, pero esto es opcional: genera un archivo con los scripts de creación, que Uds. puede correr en cualquier momento manualmente contra el SQL Server que elijan.

Generando el código

Para generar el código, seguir los siguientes pasos:

Editar los parámetros del SQL Server que están en los archivos de tecnología mostrados arriba
Ir a la línea de comando.
Agregar al PATH el directorio \bin del AjGenesis 0.5 bajado
Ir al directorio AjOmar del ejemplo bajado
Ejecutar

GenerateProject AjOmar CSharp2Nh

para generar el ejemplo en C Sharp 2.
Ejecutar

DeployDatabase AjOmar CSharp2Nh

para crear la base en el SQL Server local (en caso de querer hacerlo manualmente ver el código generado para crear la base en Build\AjOmar\CSharp2Nh\Sql)
Si desea generar el código para VB.NET 2, ejecutar

GenerateProject AjOmar VbNet2Nh

La solución generada

En ambos casos, VB.NET o C Sharp, se generan directorios dentro de Build\AjOmar:

Si vemos el ejemplo C Sharp, queda un archivo de solución en Build\AjOmar\CSharp2Nh\Src, que al abrirlo en el Visual Studio 2005 queda:

Hay varios proyectos de librerías de clases:

AjNHibernate: contiene las clases para el manejo de las llamadas al NHibernate, como configuración, factoría y obtención de sesiones.
AjOmar.Data: acá están los DAO (Data Access Objects, aunque son clases con métodos estáticos) y el .hbm de mapeo, codificado como recurso embebido en el proyecto.
AjOmar.Entities: las entidades del dominio.
AjOmar.Services: simplemente una capa de servicio delgado.

Veamos como ejemplo la entidad Company en AjOmar.Entities:


/*
 *    Project AjOmar
 *        Example AjOmar for (N)Hibernate
 *    Entity    Company
 *        Company Entity
 *    
 */

using System;

namespace AjOmar.Entities {

    public class Company : Client {

//    Private Fields

        private string companyName;
        private string contactName;

//    Default Constructor

        public Company() {
        }

//    Factory Methods

        public static Company Create(
            string companyname ,
            string contactname 
            ) {
            Company company;

            company = new Company();

            company.CompanyName = companyname;
            company.ContactName = contactname;

            return company;
        }

//    Public Properties

    
        public string CompanyName
        {
            get {
                return companyName;
            }
            set {
                companyName = value;
            }
        }

    
        public string ContactName
        {
            get {
                return contactName;
            }
            set {
                contactName = value;
            }
        }


    }

}

Gracias al ejemplo inicial que me envió Omar, pude generar un .hbm con subentidades:

<?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0">
    <class name="AjOmar.Entities.Client, AjOmar.Entities" table="ajom_clients">
        <id name="Id" column="Id" type="Int32" unsaved-value="0">
            <generator class="native"/>
        </id>
        <property column="PhysicalAddress" type="String" name="PhysicalAddress" length="255"/>
        <property column="ContactEmail" type="String" name="ContactEmail" length="255"/>
        <property column="RegisterDate" type="DateTime" name="RegisterDate" length="255"/>
        <property column="Active" type="Boolean" name="Active" length="255"/>
        <joined-subclass name="AjOmar.Entities.Company, AjOmar.Entities" table="ajom_companies">
            <key column="Id" />
            <property column="CompanyName" type="String" name="CompanyName" length="255"/>
            <property column="ContactName" type="String" name="ContactName" length="255"/>
        </joined-subclass>
        <joined-subclass name="AjOmar.Entities.User, AjOmar.Entities" table="ajom_users">
            <key column="Id" />
            <property column="FirstName" type="String" name="FirstName" length="255"/>
            <property column="LastName" type="String" name="LastName" length="255"/>
        </joined-subclass>
    </class>
</hibernate-mapping>

Hay un proyecto web AjOmar.WebClient, con una página inicial, un tema, un master page, y un directorio con páginas de navegación y actualización del modelo:

Desde el menú de administración pueden actualizarse los datos:

No es un "qué bruto, qué página", pero algo funciona... Jeje, lo mío no es el diseño gráfico. :-)

Noten que en web.config, coloqué la configuración del NHibernate:

    <nhibernate>
        <add 
            key="hibernate.connection.provider"          
            value="NHibernate.Connection.DriverConnectionProvider" 
        />
        <add 
            key="hibernate.dialect"                      
            value="NHibernate.Dialect.MsSql2000Dialect" 
        />
        <add 
            key="hibernate.connection.driver_class"          
            value="NHibernate.Driver.SqlClientDriver" 
        />
        <add 
            key="hibernate.connection.connection_string" 
            value="server=(local);database=AjOmar;uid=sa;pwd=" 
        />
    </nhibernate>

y un HttpModule para manejar la sesión:

       <httpModules>
         <add type="AjNHibernate.SessionHttpModule, AjNHibernate" name="NHSessionModule" />
       </httpModules>

Próximos pasos

Quedan para encarar en la próxima versión

Utilizar la última versión de NHibernate (con esquema 2.2)
Ver de poner los tipos SQL que pedía Omar
Probar contra SQL Server 2005
Ver de agregar "lazy" en las joined subclasses del mapeo
Generar para VB.NET 1.x/CSharp 1.x
Generar con conceptos de Domain-Driven Design (capa Presentation+Application+Domain+Infrastructure).
Generar código para Java con Hibernate y MySql

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com

Generando código para NHibernate (Parte 1)

lopez — Sun, 05 Aug 2007 13:18:42 GMT

Ya en algún "post" anterior, Generando aplicaciones con AjGenesis comenté sobre cómo el proyecto AjGenesis genera código para distintas plataformas, incluyendo VB.Net 1/2, C# 1/2, y usando ADO.NET o NHibernate. El proyecto está basado en templates, que cualquier puede adaptar para generar como quieran los artefactos de texto que necesiten, en cualquier tecnología. AjGenesis está escrito en VB.Net, y es un proyecto de código abierto.

Gracias a la lectura de otro "post", Sobre la generación de código, surgió una iniciativa de Omar del valle Rodríguez, para generar un modelo que le interesa, en NHibernate. Pueden ver el thread original en la excelente lista de arquitectura del Microsoft User Group de Argentina:

http://www.mail-archive.com/arquitectura@mug.org.ar/msg00349.html

(me temo que no quedaron aún publicadas las respuestas al mensajes, entre ellas la propuesta del bueno de Omar).

La idea de Omar es implementar, según sus propias palabras:

"Una empresa, cuyos clientes pueden ser personas o empresas, los clientes se deben tratar como tal, independientemente de si es persona o empresa, pero deberíamos poder identificar a cada uno por separado..

En el resultado que espero siempre veo que se genere: 3 tablas, cliente, persona y empresa, con una relación uno a uno entre ellas partiendo de cliente.. y en el modelo sería un objeto cliente del cual heredan persona y empresa."

Bien, interesante modelo. Me llevará a implementar por primera vez, en mis modelos (recuerden que el modelo del AjGenesis ES LIBRE, cualquiera puede armar el modelo que quiera), entidades con generalización. Aquí Cliente será la generalización de Persona y Empresa. Según lo pedido por Omar, habrá tres tablas: una donde estan los datos de todos los Clientes, otra donde estarán los datos adicionales de una Persona, y otra para los datos específicos de Empresa.

Luego, en la discusión del tema, llegamos a tener como objetivo a generar, de nuevo, en palabras de Omar:

1- Client.hbm.xml (archivo de mapeo para NH)
2- Client.cs (entidad en C# que describe un cliente)
3- User.cs (entidad en C# que describe un cliente de tipo "persona")
4- Company.cs (entidad en C# que describe un cliente de tipo "empresa")
5- ClientFactory.cs (Factory que me permite manipular una entidad Cliente [Insert, Update, Delete, GetAll, GetByID, GetAllCompany, etc, etc])
6- Client.sql (script para SQL Server con el código de las tablas a incluir)

Además, podríamos generar el código para VB.Net, y algunas páginas ASP.NET para navegar y actualizar las entidades del modelo, como hacen los anteriores ejemplos de AjGenesis. Omar proveerá una implementación destino, y armaremos el modelo, los templates y tareas en AjGenesis, para producir esos archivos y algo más.

El problema está planteado. Veremos cómo progresa, en nuevos artículos.

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/

Recursos sobre Hibernate

lopez — Fri, 20 Jul 2007 10:42:52 GMT

En varios de los ejemplos que vemos en mis cursos de Java, terminamos usando Hibernate, la librería de ORM (Object Relational Mapping) para Java. Es realmente muy útil para armar un modelo de dominio con relaciones entre objetos, y manejar su persistencia de una forma bastante transparente. Ya escribiré sobre generar código desde AjGenesis para Hibernate (así como para NHibernate, algo adelanté en Generando aplicaciones con AjGenesis).

Mientras, hay varias páginas con recursos, tutoriales y ejemplos de uso de Hibernate. Una de las más abarcativas es:

Mini-guide: Hibernate and NHibernate

aunque por ahora es en su mayoría sólo sobre Hibernate.

Algunos enlaces más:

Hibernate vs. Spring
Developing J2EE Applications Using Hibernate Annotations and Spring MVC
Object Generation: A Better Approach to Hibernate Integration
Using Spring with JDO and Hibernate
Bridge the gap between Struts and Hibernate

Complete Hibernate 3.0 Tutorial
Hibernate Examples
Using Hibernate as a JDBC

Más enlaces en

http://del.icio.us/ajlopez/hibernate

http://del.icio.us/ajlopez/orm

http://del.icio.us/ajlopez/nhibernate

Nos leemos!

Angel "Java" Lopez
http://www.ajlopez.com/