Hola a todos nuevamente, continuando con el post anterior. Hoy quiero darles un concepto muy simple de usar CSLA .NET en un Proyecto con Windows Forms.

Primero, en el Proyecto DemoCSLA.Datos vamos a crear una clase parcial que nos permita crear unos métodos estáticos que luego podremos usar a lo largo del Proyecto:

Le pondremos como nombre Cliente.Designer.cs y declaramos dos métodos:

GetClienteByID

public static Cliente GetClienteByID(int ID)
		{
			using (var ctx = new DemoCSLAContainer())
			{
				var customer = ctx.ClienteSet.SingleOrDefault(c => c.ID == ID);
 
				if (customer != null)
					return customer;
 
				throw new InvalidOperationException("No se encuentra el Cliente con el ID especificado");
			}
		}

GetAllClientes

public static IEnumerable<Cliente> GetAllClientes()
		{
 
			using (var ctx = new DemoCSLAContainer())
			{
				return ctx.ClienteSet.ToList();
			}
 
		}

Resolvemos las referencias y compilamos.

Luego, debemos hacer la referencia a través de NuGet a los siguientes paquetes en el proyecto DemoCSLA.Negocio:

Snap6

Como podrán observar CSLA, nos trae diversas plantillas que podremos usar a lo largo del proyecto, los cuales una vez instalados no requieren descargar nuevamente en todos los proyectos a utilizar, de eso hablaremos a continuación.

Creamos dos carpetas en el proyecto DemoCSLA.Negocio:

Snap7

Dentro de Editables, crearemos una Clase llamada CustomerEdit y colocaremos el siguiente código:

[Serializable]
	public class CustomerEdit : BusinessBase<CustomerEdit>
	{
 
		#region Properties
		public static readonly PropertyInfo<int> IDProperty = RegisterProperty<int>(c => c.ID);
		public int ID
		{
			get { return GetProperty(IDProperty); }
			set { SetProperty(IDProperty, value); }
		}
 
		public static readonly PropertyInfo<string> NameProperty = RegisterProperty<string>(c => c.Name);
		public string Name
		{
			get { return GetProperty(NameProperty); }
			set { SetProperty(NameProperty, value); }
		}
 
		public static readonly PropertyInfo<string> RUCProperty = RegisterProperty<string>(c => c.RUC);
		public string RUC
		{
			get { return GetProperty(RUCProperty); }
			set { SetProperty(RUCProperty, value); }
		}
 
		public static readonly PropertyInfo<string> PhoneProperty = RegisterProperty<string>(c => c.Phone);
		public string Phone
		{
			get { return GetProperty(PhoneProperty); }
			set { SetProperty(PhoneProperty, value); }
		}
 
		public static readonly PropertyInfo<string> EmailProperty = RegisterProperty<string>(c => c.Email);
		public string Email
		{
			get { return GetProperty(EmailProperty); }
			set { SetProperty(EmailProperty, value); }
		}
		#endregion
 
		#region Business Rules
		protected override void AddBusinessRules()
		{
			base.AddBusinessRules();
		}
		#endregion
 
		#region Factory Methods
 
		public static CustomerEdit NewCustomerEdit()
		{
			return DataPortal.Create<CustomerEdit>();
		}
 
		public static CustomerEdit GetCustomerEdit(int id)
		{
			return DataPortal.Fetch<CustomerEdit>(id);
		}
 
		public static void DeleteCustomerEdit(int id)
		{
			DataPortal.Delete<CustomerEdit>(id);
		}
		#endregion
 
		#region Data Access
		private void DataPortal_Fetch(int id)
		{
			var customer = Cliente.GetClienteByID(id);
 
			using (BypassPropertyChecks)
			{
				ID = customer.ID;
				Name = customer.RazonSocial;
				RUC = customer.RUC;
				Phone = customer.Telefono;
				Email = customer.Correo;
			}
			BusinessRules.CheckRules();
		}
 
		[Transactional(TransactionalTypes.TransactionScope)]
		protected override void DataPortal_Insert()
		{
			using (var ctx = DbContextManager<DemoCSLAContainer>.GetManager())
			{
				var customer = new Cliente();
 
				DoInsertUpdate(customer);
 
				ctx.DbContext.ClienteSet.Add(customer);
				ctx.DbContext.SaveChanges();
			}
		}
 
		private void DoInsertUpdate(Cliente customer)
		{
			using (BypassPropertyChecks)
			{
				customer.ID = ID;
				customer.RazonSocial = Name;
				customer.RUC = RUC;
				customer.Telefono = Phone;
				customer.Correo = Email;
			}
		}
 
		[Transactional(TransactionalTypes.TransactionScope)]
		protected override void DataPortal_Update()
		{
			using (var ctx = DbContextManager<DemoCSLAContainer>.GetManager())
			{
				var customer = Cliente.GetClienteByID(ID);
 
				DoInsertUpdate(customer);
 
				ctx.DbContext.SaveChanges();
			}
		}
 
		protected override void DataPortal_DeleteSelf()
		{
			DataPortal_Delete(ReadProperty(IDProperty));
		}
 
		[Transactional(TransactionalTypes.TransactionScope)]
		private void DataPortal_Delete(int id)
		{
			using (var ctx = DbContextManager<DemoCSLAContainer>.GetManager())
			{
				var customer = Cliente.GetClienteByID(ID);
 
				ctx.DbContext.ClienteSet.Remove(customer);
				ctx.DbContext.SaveChanges();
			}
 
		}
		#endregion
 
	}

Las plantillas que descarga CSLA a través de NuGet nos instala una serie de Snippets que podremos usar mientras codificamos:

Snap8

Como se puede apreciar, las propiedades de CSLA .NET tienen una sintaxis especial, esto es debido a que cada vez que se lee o escribe en una propiedad, CSLA, realiza una validación a nivel de propiedad para comprobar si el usuario tiene acceso, si es así luego dispara un evento que informa a la clase que el contenido de la propiedad ha cambiado.

Observen que todas las clases de Objetos editables deben heredar de BusinessBase, donde T es la Clase CustomerEdit, y además éstas deben tener el atributo Serializable, ya que los objetos “viajan” a través del DataPortal.

Luego crearemos dos clases más dentro de la Carpeta ReadOnly:

Snap9

Estas dos clases representan una Lista de Clientes, pero heredando clases de CSLA, ya que su finalidad es únicamente leer registros, de esta manera no usamos una Lista de CustomerEdit, porque si no estaríamos usando un objeto de edición para mostrarlo en una grilla y eso no sería tan óptimo.

Una vez terminado, se procede a compilar el código y nos dirigimos al proyecto DemoCSLA.Windows y a través de NuGet le indicamos que también use el paquete CSLA Core.

Snap2

Como este es sólo un primer ejemplo colocaremos un único formulario, el mantenimiento de registro de Clientes, para ello he empleado el siguiente diseño:

Snap10

Como ven, es algo realmente simple, el código no lo muestro porque sino haría este post muy extenso, al final del mismo podrán descargarlo.

Ya que cada objeto de negocio que hemos creado, son enlazables, podremos agregarlo en la ventana de Origenes de Datos:

Snap1

Snap20

Dichos objetos se arrastran al diseño del formulario y ya quedaría como el diseño anterior. Si probamos la aplicación se puede apreciar que las operaciones son simples de manejar y prácticamente el código del Windows Forms es mínimo.

Si quisiéramos agregar un control de validación de campos obligatorios bastaría con añadir el ensamblado System.ComponentModel.DataAnnotations al proyecto DemoCSLA.Negocio y añadirlo a cada propiedad.

Snap4

De esta manera, solo se compila todo el proyecto, se agrega un control ErrorProvider al formulario y se establece su propiedad DataSource con el BindingSource que contiene el objeto editable, en el código no se cambia nada.

Snap5

Y Listo.

Snap11

Como ven, CSLA .NET nos permite agilizar el proceso de desarrollo en aplicaciones de negocio para Windows, en el próximo post, veremos la aplicacion completa.

ver-github1

Espero que hay sido de su agrado.

Compartan y comenten.

Anuncios