AjModel: Modelo por Código (Parte 2) Modelos y Repositorios

Anterior Post

Estuve trabajando en mi projecto AjModel. Pueden bajar el avance del código desde mi AjCodeKatas Project dentro de trunk/AjModel. Agregué una clase Model, y mejoré EntityModel y PropertyModel:

El modelo referencia a todos los modelos de entidades que quiero tomar de mi modelo ya codificado. Recordemos: AjModel se basa y enriquece un modelo ya codificado de clases, permitiendo agregar información como descripciones para humanos, leyendas, etc. La idea es generar automáticamente la UI desde el modelo en código, para diferentes tecnologías. El modelo de AjModel permite establecer ese puente entre nuestro modelo en código y las distintas UI. El modelo enriquecido debería servir para esa función AUN cuando no se le agregue nada. Y servir de base para generar la UI en ejecución. El modelo enriquecido debe ser poder consumido por distintas tecnologías de UI: la aplicación “prueba de concepto” que incluyo en el código es ASP.NET MVC.

Como anticipaba en el post anterior, agregué una interfaz “fluent” a EntityModel y PropertyModel. Hay métodos de extensión, wrappers/builders, como:

Algunos ejemplos de uso, tomados de los tests:

EntityModel<Customer> model = new EntityModel<Customer>();
FluentEntityModel<Customer> fluentModel = new FluentEntityModel<Customer>(model);
fluentModel.Name("BusinessCustomer")
    .SetName("BusinessCustomers")
    .Descriptor("Business Customer")
    .SetDescriptor("Business Customers");
//..
Model model = new Model();
var entityModel = model.ForEntity<Customer>();
entityModel.Descriptor("Business Customer")
    .SetDescriptor("Business Customers");
//..
Model model = new Model();
model.ForEntity<Customer>().Property(
    c => c.Name,
    pm => pm.Descriptor("Customer Name")
            .Description("The Customer Name")
);


donde pm es un FluentPropertyModel.



En el proceso de la UI, quiero recuperar una entidad por su identidad, para poder mostrar su detalle. Y también, quiero obtener una lista de entidades para alimentar una grilla. Entonces, necesito algo para manejar entidades, como una lista, y que se implemente por abajo en distintas tecnologías. La actual implementación se basa en una lista en memoria:





En mis planes está escribir ejemplos de adapter para NHibernate, Entity Framework, pero eso todavía está solo en papel y en mi mente ;-)



Ejemplos de uso:



this.entityModel = new EntityModel<Customer>();
this.domain = new SimpleDomain();
this.repository = new Repository<Customer>(this.entityModel, this.domain.Customers);


Noten que hay repositorios con tipo, usando generics. Y necesita para manejarse un EntityModel, y (en la actual implementación) un IList de entidades. El Context contiene una lista de todos los repositorios:



var entityModel = new EntityModel<Customer>();
var domain = new SimpleDomain();
var repository = new Repository<Customer>(entityModel, domain.Customers);
var context = new Context();
context.AddRepository(this.repository);
var repo = context.GetRepository("Customer");


SimpleDomain es una clase que creé para los tests:



public class SimpleDomain
{
    public SimpleDomain()
    {
        this.Customers = new List<Customer>();
        for (int k = 1; k <= 10; k++)
        {
            Customer customer = new Customer()
            {
                Id = k,
                Name = string.Format("Customer {0}", k)
            };
            this.Customers.Add(customer);
        }
    }
    public IList<Customer> Customers { get; set; }
    public ProductList Products { get; set; }
}


Un modelo puede ser creado alimentándose de la estructura de una clase como SimpleDomain. Descubre las propiedades públicas que implementan IList (por ahora):



var model = new Model(typeof(SimpleDomain));
var entityModel = model.GetEntityModel("Customer");
Assert.IsNotNull(entityModel);
entityModel = model.GetEntityModel("Product");
Assert.IsNotNull(entityModel);

Planeo agregar automáticamente todos los tipos de un assembly que satisfagan un predicado, como tener “Entities” en su namespaces. new Model(IEnumerable<Type> types) debería bastar.

Las entidades (objetos) pueden ser agregadas y recuperadas usando un repositorio:



Customer entity = new Customer() { Id = 1000 };
this.repository.AddEntity(entity);
Customer newEntity = this.repository.GetEntity(1000);


Y pueden ser removidas, también.



El modelo de entidad tiene la información para crear nuevas entidades desde valores (en un diccionario con pares nombre/valor). Una capacidad que necesito para usar en la creación de entidades desde la UI:



EntityModel<Person> model = new EntityModel<Person>();
IDictionary<string, object> values = new Dictionary<string, object>()
{
    { "Id", 1 },
    { "FirstName", "Joe" },
    { "LastName", "Doe" },
    { "Age", "30" }
};
object entity = model.NewEntity(values);


En próximos posts, discutiré alguna implementación de la UI en MVC. Todo es “work in progress”, pero el proyecto ya va tomando forma. Y me divieggtto como loco ;-)



Nos leemos!



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

This entry was posted in 1389, 15035, 3463, 5374. Bookmark the permalink.

Leave a Reply

Your email address will not be published. Required fields are marked *


*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>