Visual Studio 2010 SP1

Ya está disponible para descargar el primer Service Pack de Visual Studio 2010.

Visual Studio 2010

Visual Studio 2010

Tenemos dos alternativas para la descarga:

  • Utilizando Microsoft Web Platform Installer del cual ya hemos hablado en otras entradas y que podemos descargar desde aquí (tamaño aproximado 800 kb y la instalación es on-line). Instala las características mínimas necesarias para la versión de VS2010 que tengamos instalado.
  • Descargando la imagen ISO (tamaño aproximado 1.5GB) que nos permitirá instalar el SP1 sobre cualquier versión de VS2010 y podremos personalizar las características a instalar. Descargar desde aquí.

En el primer link podremos encontrar información sobre las características que trae el SP.

Anuncios

Monodroid: Android en .NET

Monodroid es un SDK (software development kit) que nos permite desarrollar aplicaciones Android bajo un entorno .NET, y nos provee un plugin para que podemos trabajar con Visual Studio 2010 como IDE (actualmente solo con C# como lenguaje).

En este post vamos a explicar los pasos necesarios para preparar el entorno de desarrollo de Monodroid en Visual Studio 2010.

Primer Paso: Instalando el SDK de Java

Lo primero que debemos hacer es descargar e instalar el SDK de Java desde aquí (archivo jdk-6u24-windows-i586.exe). Para aquellos que aún no lo sepan las aplicaciones Android están desarrolladas sobre Java, por lo que es preciso tener instalado dicho entorno para correr el emulador y nuestras app.

Descargando el SDK de Java

Descargando el SDK de Java

Segundo Paso: Instalando el SDK de Android

Deberemos bajar el instalador del SDK desde aquí (archivo installer_r10-windows.exe). Descargado el instalador, ejecutamos el mismo y finalizada la instalación ejecutamos el SDK Manager desde el cual vamos a descargar e instalar los siguientes paquetes:

  • Android SDK Tools, revision 10
  • Android SDK Platform-tools, revision 3

También deberemos instalar las SDK Platforms que prefiramos, como por ejemplo la de la versión 2.2 de Android:

  • SDK Platform Android 2.2, API 8, revision 2
Instalación del SDK de Android

Instalación del SDK de Android

Tercer Paso: Configurando el emulador

Es hora de configurar nuestro emulador, el mismo será utilizado por Visual Studio 2010 para ejecutar nuestras aplicaciones Android. Para ello ejecutamos nuevamente el SDK Manager y nos dirigimos a la opción “Virtual Devices“.

Visualizando los emuladores creados.

Visualizando los emuladores creados.

Por defecto deberíamos tener definidos dos dispositivos, uno para la versión 2.1 y otro para la 2.2. Sin embargo podemos definir nuevos dispositivos haciendo click en el botón “New…“. Al crear un nuevo dispositivo virtual podremos definir la versión en que va a correr el mismo (esto va a depender de las SDK Platform que hayamos instalado previamente), el tamaño disponible para la SD Card, resolución de la pantalla y hardware sobre el que va a correr.

Cuarto Paso: Instalando el plugin de Monodroid para Visual Studio 2010

Bien, llegamos al último paso, para ello vamos a descargar el plugin desde aquí (archivo monodroid9639.msi). Es importante que antes de comenzar la instalación no tengamos abierto VS2010.

Instalación Plugin Monodroid

Instalación Plugin Monodroid

Finalizada la instalación vamos a abrir Visual Studio 2010 y a crear un nuevo proyecto. Para ello vamos a “File\New\Project…” y en la ventana que se nos abre vamos a seleccionar el nuevo template de proyectos Visual C# – Monodroid. Hecho esto veremos tres tipos de proyectos, para el ejemplo vamos a crear una aplicación Monodroid Application:

Creando nuestra primer aplicación Monodroid

Creando nuestra primer aplicación Monodroid

Ahora simplemente vamos a ejecutar la aplicación, veremos que se nos va a presentar una ventana que nos pedirá que selecciones un disposivo (la lista va a aparece vacía debido a que aún no tenemos un emulador corriendo). Para levantarlo vamos hacer click en “Start Emulation Image“:

Seleccionando el emulador

Seleccionando el emulador

Ahora nos aparecerá una lista con los dispositivos virtuales que hayamos definido al momento de configurar los emuladores durante la instalación (ver paso 3). Elegimos la versión que vamos a utilizar y aceptamos.

Lista de emuladores

Lista de emuladores

Cuando seleccionamos la versión que vamos a utilizar y pulsamos “OK” veremos que se va a abrir el emulador. También vamos a ver que ya tenemos un dispositivo disponible en donde podemos instalar y correr nuestra app:

Listado de dispositvos

Listado de dispositvos

Antes de ejecutar nuestra aplicación debemos esperar a que el emulador bootee. Levantado Android en el dispositivo hacemos “OK” en la ventana emergente para que se instale nuestra aplicación. Veremos que antes de que se ejecute nuestra app se instalara en el emulador el entorno de Monodroid necesario para correr la app:

Instalando Monodroid en el emulador

Instalando Monodroid en el emulador

Terminado de instalarse el entorno Monodroid en el emulador podremos probar nuestra app:

Nuestra primer aplicación Android!

Nuestra primer aplicación Android!

Es importante que si vamos a utilizar el emulador de Android 2.2 (o cualquier otra versión) en las propiedades del proyecto tengamos dicha versión definida.

Mas información detalla de la instalación la pueden encontrar aquí.

ASP.NET MVC 3: Client-Side Validation Enabled por Default

En las versiones anteriores de MVC, era necesario invocar al método Html.EnableClientValidation() desde una vista para habilitar la validación del lado del cliente. Por ejemplo debíamos escribir algo similar a esto en la vista:

1:<script type="text/javascript" src="/Scripts/MicrosoftAjax.js"/> 
2:<script type="text/javascript" src="/Scripts/MicrosoftMvcValidation.js"/> 
3:<h2> Create</h2> 
4: <% Html.EnableClientValidation();  %>
5: <% using  (Html.BeginForm()) { %>  
6:   <%=  Html.ValidationSummary(true )  %>  
7:
8:       <fieldset> 
9:           <legend> Campos</legend> 
10:           <div  class="editor-label"> 
11:                <%=  Html.LabelFor(model => model.Nombre)  %>  
12:           </div> 
13:           <div  class="editor-field"> 
14:                <%=  Html.TextBoxFor(model => model.Nombre)  %>  
15:                <%=  Html.ValidationMessageFor(model => model.Nombre)  %>  
16:           </div> 
17:           <p> 
18:               <input  type="submit"  value="Create"  /> 
19:           </p> 
20:       </fieldset> 
21:<% }  %>

Lo que teníamos que tener en cuenta era la invocación al método EnableClientValidation y las referencias a los scripts MicrosoftAjax,js MicrosoftMvcValidation.js (este último nos permitía validar las propiedades de un modelo que tenían asignados atributos de validación DataAnnotations desde el lado del cliente).

En MVC 3 este paso ya no es necesario ya que la validación del lado del cliente está habilitada de forma predeterminada. Podemos habilitarla o deshabilitarla modificando la siguiente entrada en nuestro web.config:

1:<appSettings> 
2:  <add key= "ClientValidationEnabled " value= "true "/>  
3:  <add key= "UnobtrusiveJavaScriptEnabled " value= "true "/>  
4:</appSettings>

La key ClientValidationEnabled en true nos permite trabajar con la validación del lado del cliente de manera predetermina. La key UnobtrusiveJavaScriptEnable en true nos evitara mezclar el código javascript dentro del HTML, tal como se explico en este post.

También es necesario agregar en la vista la referencia a la librería de jQuery jquery.validate.js. Esta librería es la que trabajara en conjunto con los atributos DataAnnotation que hayamos definido en el modelo de la vista para poder realizar las validaciones client-side.

Veamos todo con un ejemplo muy simple, lo primero que vamos hacer es crear un modelo reducido para la entidad Cliente y al mismo vamos a definirle el atributo Nombre como requerido:

1: using  System;
2: using  System.Collections.Generic;
3: using  System.Linq;
4: using  System.Web;
5: using  System.ComponentModel.DataAnnotations;
6:
7: namespace Mvc3.Models
8: {
9:     public class ClienteModel 
10:     {
11:         [Required(ErrorMessage= "El nombre es obligatorio.")]
12:         public string Nombre { get; set; }
13:
14:         public int? Edad { get; set; }
15:     }
16: }

En el controlador vamos a definir los métodos de acción de creación del cliente:

1: namespace Mvc3.Controllers
2: {
3:     public class ClienteController : Controller 
4:     {
5:         public ActionResult Create()
6:         {
7:            return View();
8:         }
9:
10:         [HttpPost]
11:         public ActionResult Create(ClienteModel model)
12:         {
13:             if(ModelState.IsValid)
14:             {
15:                 return View();
16:             }
17:
18:             return View(model);
19:         }
20:     }
21: }

Finalmente vamos a crear la vista, hacemos click derecho sobre el método de acción Create, y en el menú elegimos “Add View…“. En la ventana que se nos abre elegimos que sea de tipado fuerte y elegimos nuestro modelo previamente creado: ClienteModel. También vamos a seleccionar que sea un formulario de creación y para quinenes hayan definido una master page la seccionan. En nuestro caso vamos a usar como ViewEngine Razor.

Configurando la vista

Configurando la vista

Van  a ver que al crear la vista esta ya incluye las referencias a los script necesarios para la validación del lado del cliente:

1:  @model   Mvc3.Models.ClienteModel 
2:  @{
3:     ViewBag.Title = "Create";
4:     Layout = "~/Views/Shared/_Layout.cshtml";
5:  }
6:
7: <h2>Create</h2> 
8:
9: <script src="  @Url.Content("~/Scripts/jquery.validate.min.js")"  
10:         type="text/javascript"></script> 
11: <script src="  @Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"  
12:         type="text/javascript"></script> 
13:
14:  @ using Html.BeginForm()) {
15:      @ Html.ValidationSummary(true )
16:     <fieldset> 
17:         <legend>ClienteModel</legend> 
18:
19:         <div class="editor-label"> 
20:              @ Html.LabelFor(model => model.Nombre)
21:         </div> 
22:         <div class="editor-field"> 
23:              @ Html.EditorFor(model => model.Nombre)
24:              @ Html.ValidationMessageFor(model => model.Nombre)
25:         </div> 
26:
27:         <div class="editor-label"> 
28:              @ Html.LabelFor(model => model.Edad)
29:         </div> 
30:         <p> 
31:             <input type="submit"  value="Create"  /> 
32:         </p> 
33:     </fieldset> 
34: }
35: <div> 
36:      @ Html.ActionLink("Back to List" , "Index" )
37: </div> 

Ya tenemos todo configurado, ejecutamos y podremos chequear que definitivamente las validaciones se hacen del lado del cliente.

Validación del formulario

Validación del formulario

Si queremos validar que esto es del todo correcto, deshabilitamos en el web.config la entrada ClientValidationEnabled y volvemos a ejecutar. Efectivamente vamos a ver que en este caso la validación se hace desde el servidor provocando el submit del formulario.

Espero que les haya sido de utilidad!