Roque
Rueda
Mi hermano me solicito que le creara un sitio web para
venta de ropa así que para apoyarle he decidido crear un sitio web ASP .net en
donde el pueda promocionar las ventas.
Primero
vamos a crear una nueva solución.
En el tipo de proyecto vamos a seleccionar una
solución en blanco y vamos a darle el nombre que deseamos.
Ahora ya tenemos nuestra solución, una solución puede
estar compuesta de diversos proyectos es por eso que nosotros vamos a generar
proyectos para que cada responsabilidad quede separada adecuadamente. En este
caso vamos a generar una solución con N capas. (Un poco de información aquí.)
Para esto vamos a generar los proyectos necesarios en
este caso vamos a crear DataAccessLayer, BusinessLogic, WebPresentation,
BusinessEntities, UnitTest, IntegrationTest.
·
Data Access Layer: Esta capa es la encargada de acceder a
los datos en la aplicación (dll).
·
Business Logic: Esta capa contendrá todas las reglas y operaciones
de negocio (dll).
·
Presentation: Esta capa es la interfaz de usuario que se va a
implementar en ASP. NET (asp.net application).
·
Bussiness Entities: Esta capa va a contener contenedores de datos
que se comparten en las demás capas (dll).
·
Unit Test: Esta capa contendrá las pruebas unitarias de las
funcionalidades que se utilicen (unit testing).
·
Integration Test: Esta capa contiene las pruebas de
integración entre entidades, capas o sdks diversos (unit testing).
|
Presentation
Interfaz de usuario,
Flujos de Interfaz
|
|
Business
Logic
Componentes de negocio,
Flujos de negocio.
|
|
Bussiness
Entities
Entidades de negocio
|
|
Data
Access Layer
Acceso a datos,
Acceso a servicios.
|
Hay que tomar en cuenta que esta es la estructura guía
y puede ser modificada si es necesario. Al final me ha resultado una estructura
del proyecto en el explorador de soluciones de la siguiente manera (Cambia el color VS2012):
Aquí se puede apreciar que la capa de lógica de
negocio de divide en implementación e interfaces así como la capa de acceso a
datos, la capa de entidades de negocio se ha mantenido en solo un proyecto de
biblioteca de clases (ojo no decir
librería), los proyectos de pruebas unitarias y de integración son ambos
proyectos de pruebas unitarias y finalmente la presentación es un proyecto de
asp.net. Esta estructura en VS2012 nos va a permitir separar adecuadamente cada
cuestión de la aplicación (separación de asuntos).
Ahora vamos a iniciar creando una prueba unitaria para
nuestra capa de acceso a datos, vamos a seguir el flujo de TDD (Test-driven development). Lo primero que vamos a hacer es
crear una prueba la cual va a fallar, lo cual nos va a permitir ir descubriendo
el comportamiento de nuestras piezas de software.
Para esto vamos a nuestro proyecto de pruebas
unitarias, en este caso vamos a editar la clase que se nos genera por defecto.
Para nuestro caso vamos a modificar el nombre dando clic derecho y
"rename".
Vamos a llamarla ProductManagerUnitTest.cs
ya que vamos a hacer pruebas sobre el administrador de repositorios; pero aun
no tenemos administrador de repositorios, esto es ya que vamos a aprovechar la
generación de código de VS2012 más adelante y obtener la clase necesaria.
Además vamos a cambiar el nombre al método de prueba
de TestMethod1 a GetProductListTest, quedando
nuestra clase de prueba de la siguiente manera.
using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace LuisClothes.UnitTest
{
[TestClass]
public class ProductManagerUnitTest
{
[TestMethod]
public void GetProductListTest()
{
}
}
}
Ahora vamos a iniciar pensando en representar el
mundo, tendremos una clase que se llamara ProductManager
el cual va a ser el responsable de los productos de nuestra aplicación, esto
también implica generar la clase Product
ya que el ProductManager administra
a Product. Ahora bien nuestro ProductManager va a existir en la capa
de acceso a datos, pero, ¿dónde vamos a colocar la clase Product?; la clase Product
va a ser parte de las entidades de negocio ya que será compartida por las demás
capas. Lo que se espera al mencionar GetProductList
es que se obtenga una lista de entidades Product en este caso vamos a utilizar una lista genérica y a poner
como tipo Product. Agregamos las
referencias a la capa de acceso a datos y a la capa de entidades de negocio, de
interfaces de acceso a datos y acceso a datos.
Vamos a agregar los usings para Generics y dentro de la clase using con alias para referirnos a las
capas de nuestra aplicación. Claro que ahora vamos a poner los nombres y VS se
va quejar de que no existen por lo que vamos a obtener algo como lo siguiente.
Esta prueba de momento nuestra primera tarea es
eliminar esos problemas que VS2012 nos marca para poder compilar y ejecutar la
prueba. Aquí solo vamos a escribir lo mínimo necesario. En BussinessEntities vamos a agregar la clase Product, de momento vamos a colocar las propiedades básicas sin
adentrarnos mucho en el detalle.
/*
* Copyright 2013 Roque Rueda.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LuisClothes.BusinessEntities
{
///
/// Represents a basic Product that can be sell in our store.
///
public class Product
{
///
/// Identifier of this product.
///
public int Id { get; set; }
///
/// Name of this product.
///
public string Name { get; set; }
///
/// Price of this product in MX pesos.
///
public double Price { get; set; }
}
}
Ahora que ya tenemos nuestra clase Product vamos a
construir el proyecto vamos a ver lo siguiente.
Ya nos logramos deshacer de un error de compilación,
ahora vamos a las interfaces de acceso a datos debemos generar la interfaz
IProductManager y definir el método GetProductList. Primero se crea la interfaz
haciendo clic derecho sobre el proyecto DataAccessLayerInterfaces y agregar
interfaz.
De entrada generamos la interfaz únicamente algo como
lo siguiente:
Ahora vamos a definir nuestro metodo GetProductList
pero debemos recordar que ya que vamos a obtener una lista de Product vamos a
necesitar hacer referencia a las entidades de negocio, por lo que agregamos una
referencia a BusinessEntities.
La estructura de nuestro proyecto sera algo como lo
siguiente (noten como elimine las referencias que no eran necesarias).
La definición del método será la siguiente:
Yo prefiero iniciar
agregando los comentarios del método o pieza de código que me encuentro
modificando para que así pueda desde un inicio saber que se debe esperar de
resultado. En este caso se define que se retorna la lista de todos los productos
existentes o null si no existe ningún producto.
Vemos que ya nos hemos
hecho cargo de otro error de compilacion ahora solo nos resta definir la clase
ProductManager, ya que definimos una variable IProductManager y asignamos un
ProductManager podemos inferir que ProductManager implementa la interfaz por lo
que si la contener codigo para devolver una lista de objetos. Para poder
utilizar la interfaz debemos agregar la referencia al proyecto.
Una vez hecho esto
vamos a poder implementar la interfaz.
Tambien debemos
agregar una referencia a las entidades de negocio con el fin de poder utilizar
la clase Product.
Finalmente la clase
ProductManager tendra una estructura como la siguiente:
Y ya no debemos tener
errores de compilación en nuestro código por lo que la ejecución de nuestra
prueba puede comenzar. Para eso regresamos a la prueba unitaria y vamos a hacer
clic derecho sobre el metodo de prueba y seleccionamos run test.
Cuando ejecutamos
nuestra prueba vamos a ver un resultado como el siguiente:
Nuestra prueba ha
fallado :( pero no se pongan tristes, ya que de acuerdo con nuestra forma de
trabajo la prueba debe fallar, ahora si notaron el mensaje de error nos indica
que se lanzo la excepcion NotImplementedException
esto es así debido a la implementación que se coloco en el método que
genero por nosotros amablemente VS2012. Entonces si adivinan debemos modificar
la implementación de ese método; hacemos clic en el nombre del método
GetProductList del mensaje de fallo en la prueba.
using System;
using System.Collections.Generic;
using LuisClothes.DataAccessLayerInterfaces;
using LuisClothes.BusinessEntities;
namespace LuisClothes.DataAccessLayer
{
///
/// Reprensents a product repository and contains the funtions to access the products.
///
public class ProductManager : IProductManager
{
public List CurrentProducts { get; private set; }
///
/// Populates the current products list.
///
private void PopulateProducts()
{
if (CurrentProducts == null) // Lazy creation
{
CurrentProducts = new List();
for (int i = 0; i < 10; i++)
{
CurrentProducts.Add(new Product() { Id = i, Name = "Product" + i, Price = i * 1000 });
}
}
}
#region IProductManager implementation
///
/// Get a list of products that exists in a resource repository.
///
///
/// List of all existing products or null if there aren't any product.
///
/// GetProductList()
{
// We are going to set dummy data in order to past this test.
// TODO: Add the database implementation.
PopulateProducts();
return CurrentProducts;
}
#endregion
}
}
Ahora vamos a volver a ejecutar nuestra prueba.
Saludos! Esperen la
siguiente parte.
