En dicho artículo recalcan el hecho de que NHibernate es un framework realizado por un conjunto de desarrolladores en su tiempo libre frente al Entity Framework donde tiene un equipo detrás trabajando para su desarrollo. Señalando que este hecho es el que ha causado que el Entity Framework se posicione, actualmente, por encima del NHibernate

Dentro de poco está previsto que aparezca la nueva versión NHibernate 4.0. Lo más destacado de esta versión son:

• Soporte para las bases de datos SQL Server 2012 e Ingres9
• Corrección de algunos bugs relacionados con el proveedor de LINQ y el mapeado a código entre otras.

Aunque no son muchas las novedades que incorpora esta nueva versión esperemos que con estos cambios retome el puesto que le merece como ORM.

En el siguiente enlace podéis consultar con más detalle el listado completo de las nuevas características de NHibernate:

Características de NHibernate 4

The post NHibernate 4.0 first appeared on Instituto FOC - FP Informática Online.

Para elaborar estas pruebas lo que realizas primero son las pruebas unitarias que vamos a realizar y a continuación, en base a estas pruebas, realizamos la implementación de nuestro código. Después aplicamos la refactorización a nuestro código para tener una implementación lo mas limpia posible.

Vamos a realizar un ejemplo concreto para ver como aplicamos esta técnica

Supongamos que tenemos una aplicación donde estamos implementando la gestión de nuestro carrito de la compra. En nuestro carrito de la compra vamos a poder insertar cualquier articulo, y por cada articulo que nosotros añadamos se deberá actualizar el importe total. Tendremos en cuenta que si introducimos un elemento que ya se encuentra en  nuestro carrito lo que realizaremos es un incremento de las unidades.

Partimos de las siguientes clases:

La clase Item que nos va a servir para almacenar los distintos elementos del carrito

class Item
    {

        private String _nombre;

        private Decimal _pUnidad;

        private int _ctdad;

        public String Nombre
        {
            get { return _nombre; }
            set { _nombre = value; }
        }

        public Decimal PrecioUnidad
        {
            get { return _pUnidad; }
            set { _pUnidad = value; }
        }

        public int Ctdad
        {
            get { return _ctdad; }
            set { _ctdad = value; }
        }

        public Item()
        {
            Nombre = «»;
            Ctdad = 0;
            PrecioUnidad = 0;
        }

        public Item(String _n, int ctdad, Decimal precio)
        {
            Nombre = _n;
            Ctdad = ctdad;
            PrecioUnidad = precio;
        }

    }

Y la clase Carrito para gestionar los elementos que vamos añadiendo al carrito:

 class Carrito
    {

        private List<Item> carrito;
        private Decimal _precTotal;        

        public Carrito(){
            carrito = new List<Item>();
            _precTotal = 0;            
        }
        
    }

Si seguimos las normas del TDD primero vamos a diseñar las pruebas unitarias para los distintos requisitos que vamos a cumplir:

1.- Comprobar que el importe total es de 0 cuando no tenemos ningún elemento en la cesta.

La prueba unitaria que nosotros tendremos que realizar es la siguiente:

[TestMethod]
 public void CestaCompraVacia()
 {
 // Comprobamos
 Carrito c = new Carrito();
 Assert.AreEqual(0, c.ItemsCarrito); // Comprobamos que hay cero elementos
 Assert.AreEqual(true, c.carritoVacio); // Comprobamos que el precio es 0
 }

Ahora en nuestro código dentro de nuestra clase que gestiona el carrito completaremos su código con los siguientes propiedades:

public bool carritoVacio
 {
 get { return carrito.Count == 0; }
 }

public int ItemsCarrito
{
get { return carrito.Count; }
}

2.- Comprobamos que cuando insertamos un elemento se actualiza el precio total y el número de artículos

En este caso la prueba unitaria a realizar seria la siguiente:

public void Añadir1ItemCesta()
 {
 // Comprobamos
 Carrito c = new Carrito();
 c.AddItem(new Item("CD's Virgenes",1,5));
 Assert.AreEqual(5, c.PrecTotal);
 Assert.AreEqual(1, c.ItemsCarrito);
 }

Como el método de ItemsCarrito ya lo tenemos implementando como resultado de la prueba anterior lo único que tenemos que realizar es la propiedad para obtener el precio total

public Decimal PrecTotal
 {
 get { return _precTotal; }
 set { _precTotal = value; }
 }

y el método para añadir elementos al carrito:

public void AddItem(Item it)
{
_precTotal += it.PrecioUnidad * it.Ctdad;
carrito.Add(it);         
}

3.- Comprobamos que cuando insertamos varios elementos se actualiza el precio total y el número de artículos teniendo en cuenta que podemos incluir elementos repetidos.

        [TestMethod]
        public void AñadirVariosItemCesta()
        {
            // Comprobamos 
            Carrito c = new Carrito();
            c.AddItem(new Item("CD's Virgenes", 1, 5));
            c.AddItem(new Item("CD's Virgenes", 1, 5));
            c.AddItem(new Item("CD's Virgenes", 1, 5));
            c.AddItem(new Item("DVD's Virgenes", 1, 10));
            Assert.AreEqual(25, c.PrecTotal);
            Assert.AreEqual(2, c.ItemsCarrito);
        }

Si observamos, aparentemente podemos ejecutar la prueba para ya que tenemos todos los métodos y propiedades a utilizar correctamente. Al ejecutar la prueba veremos que esta prueba no la supera ya que cada item que hemos añadido los considera como un objeto nuevo. Por lo que tendremos que modificar el método AddItem para que compruebe si el item existe y en caso de que existe modificar la cantidad almacenada.

Para ello vamos a incorporar un método de busqueda de productos y modifcaremos el método AddItem de la siguiente forma:

private Item estaItem(String nombre)
        {
            
            foreach (Item it in carrito){
                if (it.Nombre == nombre)
                    return it;
            }
            return null;
        }

        public void AddItem(Item it)
        {
            Item encontrado = estaItem(it.Nombre);
            if (encontrado!=null)
            {
                encontrado.Ctdad += it.Ctdad;
            }
            else
            {                
                carrito.Add(it);
            }
            _precTotal += it.PrecioUnidad * it.Ctdad;
        }

Podemos observar que con esta técnica de desarrollo tenemos un control mas seguro sobre el cumplimiento de los requisitos que si primero desarrollamos y luego realizamos las pruebas.

The post ¿Que es y para que nos sirven los TDD? first appeared on Instituto FOC - FP Informática Online.

Un de las herramientas mas difundidas es Xamarin

Xamarin es una herramienta que me permite crear programas en c# destinados a dispositivos basados en iOS, Android y Mac.

Esta herramienta nos proporciona el poder reutilizar nuestro código en .net. Esta herramienta nos instala las extensiones necesarias para que podamos realizar nuestro propios proyectos desde visual studio.

En el siguiente enlace tenéis disponible toda la información pública para realizar desarrollos: tutoriales, apis, … Información Xamarin

The post Xamarin. Desarrollo de aplicaciones iOS y Android en C# first appeared on Instituto FOC - FP Informática Online.

Libros sobre SharePoint, Visual Studio, Windows Phone, Windows 8, Office 365, Office 2010, SQL Server 2012, Azure, y otros mas.

Libros sobre SharePoint 2013, Office 2013, Office 365, Duet 2.0, Azure, Cloud, Windows Phone, Lync, Dynamics CRM, y otros mas.

Galleria de los libros disponibles en el MSDN

The post Libros Gratuitos en la plataforma del MSDN first appeared on Instituto FOC - FP Informática Online.

Podeis visitar el siguiente enlace para ver como ha construido un primer ejemplo y las dificultades que se ha encontrado, http://www.vsadt.com/.

The post Desarrollo de aplicaciones Android con Visual Studio first appeared on Instituto FOC - FP Informática Online.