En los últimos meses he estado ayudando para un libro sobre ASP.NET MVC que Scott Hanselman, Rob Conery y Phil Haack han estado escribiendo para Wrox. El libro ya está en producción, y estará disponible en las tiendas dentro de poco (podéis reservarlo en Amazon hoy).

He escrito el primer capítulo el libro – que es un tutorial de 185 páginas en el que explico cómo crear una pequeña, pero completa, aplicación ASP.NET MVC. El acuerdo al que llegué con Wrox es que escribiría el capítulo gratuitamente si lo ponían disponible en PDF de manera gratuita.

Me enorgullece decir que podéis descargar el capítulo completo aquí (es un PDF de 14 Mb). Está licenciado con “Creative Commons Attribution No Derivatives” – lo que significa que podéis compartir, distribuir, imprimir o dejarselo a quien queráis.

Tutorial Nerddinner ASP.NET MVC

El tutorial comienza en el ménu File->New Proyect de Visual Studio para crear un proyecto nuevo de ASP.NET MVC, y luego le vamos añadiendo funcionalidades y características de manera incremental. Entre otras cosas veremos cómo:

• Crear una base de datos
• Construir un modelo con validaciones y reglas de negocio.
• Implementar listados/detalles de datos en la UI de un sitio con Controladores y Vistas.
• Permitir el trabajo con datos (Crear, Actualizar, Eliminar)
• Usar el patrón ViewModel para pasar información desde un controlador a una vista.
• Reusar UI en un sitio con clases parciales y master pages.
• Implementar paginado eficientes de datos.
• Securizar una aplicación usando autenticación y autorización.
• Usar Ajax para actualizaciones dinámicas.
• Usar ajax para añadir mapeos interactivos.
• Crear test unitarios automáticos (incluidos injección de dependencias y objetos mock).

La aplicación que creamos en el tutorial se llama “NerdDinner”. Permite una forma de organizar, hostear y buscar sitios en los que cenar online:

Scott Hanselman ha estado hosteando Nerddinners durante años, y viene con la idea de crear el tutorial sobre la aplicación que facilita esta tarea. También hostea una versión maquillada de la aplicación en www.nerddiner.com

Enlaces de descarga

• El tutorial en PDF
• Código fuente + test unitarios de la aplicación completa.
• Para aprender más sobre el libro en la página oficial de Wrox.
• Pedir el libro en Amazon.

Espero que sirva

Microsoft’s Azure Services Platform es un grupo de tecnologías de la nube, cada una provee una serie de servicios a aplicaciones para los desarrolladores.

Podemos checar cuales son los componentes que pueden ser implementados por aplicaciones locales ejecutando diferentes escenarios como Windows, dispositivos móviles, entre otros.

Windows Azure: Nos provee un ambiente basado en Windows para ejecutar aplicaciones y almacenar datos en los data centers (servidores) de Microsoft.

Microsoft .NET Services:  Nos ofrece servicios de infraestructura distribuidos para aplicaciones basadas en la nube o de forma local.

Microsoft SQL Services: Nos provee servicios de datos en la nube basados en SQL Server.

Live Services: A través del Live Framework, nos provee acceso a la información de aplicaciones de Windows Live entre otras. Live Framework también permite sincronizar la información a través de dispositivos, computadoras de escritorio, poder encontrar y descargar aplicaciones y más.

URL:http://msdn.microsoft.com/en-us/azure/default.aspx

1.- Creamos un sitio web ASP.NET

2.- Creamos la base de datos.

3.- Creamos una tabla, en este caso estoy creando una tabla llamada tbClientes

4.-Creamos el siguiente procedimiento Almacenado para poder agregar clientes.

CREATE PROCEDURE dbo.InsertarCliente

    (
    @ID_Cliente int,
    @Nombre_Cliente varchar(50),
    @ApellidoPaterno varchar(50),
    @ApellidoMaterno varchar(50),
    @Telefono int,
    @Direccion varchar(50),
    @Descripcion varchar(MAX)
    )

AS
    INSERT INTO tbClientes VALUES(@ID_Cliente,@Nombre_Cliente,@ApellidoPaterno,@ApellidoMaterno,@Telefono,@Direccion,@Descripcion)

5.-  Agrego una clase llamada AccesoaDatos.cs

6.- Me voy al Web.config (Archivo de Configuración de la Aplicación), busquemos los tags <appSettings/> y <connectionStrings/> y modifiquemos con el siguiente código.

<appSettings>
        <add key="miProveedor" value="System.Data.SqlClient"/>
    </appSettings>
    <connectionStrings>
        <add name="miCadenaConexion" connectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Clientes.mdf;Integrated Security=True;User Instance=True" providerName="System.Data.SqlClient"/>
    </connectionStrings>

Este procedimiento nos ayuda a hacer de una manera dinámica la parte de la conexión y el escoger nuestro proveedor de acceso a datos desde código.

7.- Nos vamos a la clase y agregamos el namespace.

using System.Configuration;

8.- Agregamos el siguiente código, para hacer referencia a la cadena de conexión y al proveedor.

  public static string miCadenaConexion
    {
        get
        {
            return ConfigurationManager.ConnectionStrings["miCadenaConexion"].ConnectionString;
        }
    }

    public static string miProveedor
    {
        get
        {
            return ConfigurationManager.AppSettings["miProveedor"];
        }
    }

9.- Agrega el siguiente namespace

using System.Data.Common;

 public static DbProviderFactory dbProveedor
    {
        get
        {
            return DbProviderFactories.GetFactory(miProveedor);
        }
    }

10.- Agregamos este método, que nos permitará hacer la conexión, y tomar como parámetros el procedimiento almacenado y todos sus parámetros.

 private static void executeNonQuery(string ProcedimientoAlmacenado, List<DbParameter> parametros)
    {
        using (DbConnection conexion = dbProveedor.CreateConnection())
        {
            conexion.ConnectionString = miCadenaConexion;
            using (DbCommand comando = dbProveedor.CreateCommand())
            {
                comando.Connection = conexion;
                comando.CommandText = ProcedimientoAlmacenado;
                comando.CommandType = CommandType.StoredProcedure;

                foreach (DbParameter param in parametros)
                    comando.Parameters.Add(param);

                conexion.Open();

                comando.ExecuteNonQuery();
            }
        }
    }

11.- Agregamos el método de InsertarCliente.

  public static void insertarCliente(int ID_Cliente, string Nombre_Cliente, string ApellidoPaterno,
        string ApellidoMaterno, int Telefono, string Direccion, string Descripcion)
    {

        List<DbParameter> parametros = new List<DbParameter>();

        DbParameter param1 = dbProveedor.CreateParameter();
        param1.DbType = DbType.Int32;
        param1.Value = ID_Cliente;
        param1.ParameterName = "ID_Cliente";
        parametros.Add(param1);

        DbParameter param2 = dbProveedor.CreateParameter();
        param2.DbType = DbType.String;
        param2.Value = Nombre_Cliente;
        param2.ParameterName = "Nombre_Cliente";
        parametros.Add(param2);

        DbParameter param3 = dbProveedor.CreateParameter();
        param3.DbType = DbType.String;
        param3.Value = ApellidoPaterno;
        param3.ParameterName = "ApellidoPaterno";
        parametros.Add(param3);

        DbParameter param4 = dbProveedor.CreateParameter();
        param4.DbType = DbType.String;
        param4.Value = ApellidoMaterno;
        param4.ParameterName = "ApellidoMaterno";
        parametros.Add(param4);

        DbParameter param5 = dbProveedor.CreateParameter();
        param5.DbType = DbType.Int32;
        param5.Value = Telefono;
        param5.ParameterName = "Telefono";
        parametros.Add(param5);

        DbParameter param6 = dbProveedor.CreateParameter();
        param6.DbType = DbType.String;
        param6.Value = Direccion;
        param6.ParameterName = "Direccion";
        parametros.Add(param6);

        DbParameter param7 = dbProveedor.CreateParameter();
        param7.DbType = DbType.String;
        param7.Value = Descripcion;
        param7.ParameterName = "Descripcion";
        parametros.Add(param7);

        executeNonQuery("InsertarCliente", parametros);
    }

    private static void executeNonQuery(string StoredProcedure, List<DbParameter> parametros)
    {
        using (DbConnection con = dbProveedor.CreateConnection())
        {
            con.ConnectionString = miCadenaConexion;
            using (DbCommand cmd = dbProveedor.CreateCommand())
            {
                cmd.Connection = con;
                cmd.CommandText = StoredProcedure;
                cmd.CommandType = CommandType.StoredProcedure;

                foreach (DbParameter param in parametros)
                    cmd.Parameters.Add(param);

                con.Open();

                cmd.ExecuteNonQuery();
            }
        }
    }

12.- Nos vamos al formulario y agregamos algunos controles cuadros de texto y un botón de agregar.

Y programemos el botón agregar:

 protected void Button1_Click(object sender, EventArgs e)
    {
        AccesoaDatos.insertarCliente(int.Parse(txtID.Text),
            txtNombre.Text, txtApellidoPaterno.Text,
            txtApellidoPaterno.Text, int.Parse(txtTelefono.Text),
            txtDireccion.Text, txtDescripcion.Text);
    }

Simplemente mandamos a llamar a nuestro método y pasamos como parámetros los cuadros de texto. Ejecutalo F5

13.- Checamos si realmente lo guarda.

Del mismo modo haganlo para actualizar, borrar.

Visto en Tecnologias Microsoft

Microsoft ha liberado un nuevo control ASP.NET – <asp:chart /> – que podemos usar con ASP.NET 3.5 para permitir escenariso con gráficas:

• Descargar los controles.
• Descargar el soporte para VS 2008 para estos controles.
• Descargar los ejemplos.
• Descargar la documentación.
• Visitar el foro.

Una vez instalado, el control se muestra en el tab “Data” del toolbox de controles, y lo podemos declarar en el código de la página de la siguiente forma:

<asp:chart /> soporta un montón de opciones – entre otras pie, area, rango, puntos, circular, accumulación, distribución, interacción con ajax, donut y más. Podéis declarar los datos de la gráfica de manera estática, o usar un data-binding para calcularlos dinámicamente. En tiempo de ejecución el control generará la imagen (por ejemplo un archivo .PNG) que se referencia desde el cliente HTML de la página usando un elemento <img/>. El control tiene la habilidad de cachear esa imagen, así como guardarla en el disco en escenarios en los que haga falta. No requiere ningún otro software de servidor para instalarse, y funcionará en cualquier página ASP.NET estándar.

Para ver el sentido del uso de este control, os recomiendo que os descargueis el ejemplo de proyecto. incluye sobre 200 páginas de ejemplo que podéis ejecutar en local. Sólo tenéis que abrir el proyecto con VS 2008 y darle a ejecutar para verlo – luego podréis ver el código del .aspx de cada uno para ver cómo está implenentado.

El siguiente ejemplo (está en Char Types-> Line charts -> 3D Line and Curve Charts) muestra cómo hacer una grafica con lineas, splines y stepline:

El siguiente ejemplo( está en Chart Types-> Pie and Doughnut Charts) muestra una variedad de opciones para los donuts y los pie:

El siguiente ejemplo (está en Chart Types -> Advanced financial Charts) muestra otras gráficas:

Además de los ejemplos anteriores, podéis descargar la documentación y hacer preguntas en el foro para aprender más.

Esto nos ofrece una funcionalidad más en nuestra barra de herramientas de ASP.NET, y nos permite crear escenarios más ricos a la hora de visualizar datos en nuestras aplicaciones ASP.NET.

Espero que sirva.