Hace unos días se anunció el soporte de .NET en Azure Mobile Services. Ahora podemos escribir la lógica de nuestro backend con ASP.NET Web API y desplegarla sobre Mobile Services. Esto nos da una serie de ventajas que podemos aprovechar:

· Usar ASP.NET Web API junto con Mobile Services para crear el backend de nuestras aplicaciones.

· Publicar en Mobile Services cualquier aplicación existente desarrollada con Web API.

· Podemos utilizar toda la funcionalidad que nos ofrece Web API y de todos los frameworks de terceros basados en Web API.

· Podemos depurar nuestro Mobile Service con Visual Studio tanto en local como remotamente directamente en Azure.

· Aprovechar la monitorización y escalado automático de Mobile Services.

Creando nuestro Mobile Servicies con .NET

Ahora vamos a ver cómo podemos crear nuestro Mobile Services, para ello vamos a nuestro portal de Azure y creamos un nuevo Mobile Services, como hacíamos anteriormente.

clip_image002

A la hora de crearlo, ahora vemos como nos aparece una nueva opción donde nos da a elegir qué tipo de backend queremos utilizar (Node.js o .NET). El backend en .NET como podemos ver sigue estando en preview.

clip_image004

Ahora podemos tener diferentes Mobile Services cada uno con un tipo de backend:

clip_image006

Código de ejemplo para nuestro servicio

Una vez creado nuestro Mobile Service, necesitamos publicar el código de este. Como ya hemos mencionado antes podemos utilizar cualquier aplicación desarrollada con Web API. Aquí vamos a ver como descargar el código de ejemplo que nos proporcionan desde el portal de Azure. Este lo podemos encontrar en la pantalla principal de nuestro servicio, bajo la opción de conectar una aplicación existente con nuestro servicio.

clip_image008

Ahora vamos a ver la estructura del código de ejemplo que nos descarga, que como vamos a ver simplemente es un proyecto Web API con unos cuantos paquetes de Nuget ya instalados.

clip_image009

Como vemos, el código ya nos trae un ejemplo de manejar TO-DOs para ver cómo podemos organizar nuestro código. En el ejemplo podemos encontrar la siguiente estructura:

· Carpeta DataObject, encontramos los diferentes modelos que utilizamos.

· Carpeta Models, encontramos el contexto de acceso a base de datos. En este contexto tenemos que añadir los diferentes modelos que creemos.

· Carpeta Controllers, donde encontramos la lógica de negocio de nuestro backend.

En el ejemplo simplemente nos dan una estructura donde nos facilitan el desarrollo de nuestro backend. Pero como hemos comentado antes, podemos subir cualquier aplicación web creada con Web API por lo que no es obligatorio seguir el esquema que nos dan. Por lo que si queremos organizar nuestro código de otra forma o utilizar cualquier otro tipo de ORM para el acceso a datos, podemos realizarlo.

Los controladores serían las diferentes “tablas” que podemos llamar desde nuestros clientes de Mobile Services, así que vamos a ver cómo se implementan los controladores:

 1: public class TodoItemController : TableController<TodoItem>
 2:     {
 3:         protected override void Initialize(HttpControllerContext controllerContext)
 4:         {
 5:             base.Initialize(controllerContext);
 6:             MSDemoDotNetContext context = new MSDemoDotNetContext(Services.Settings.Name.Replace('-', '_'));
 7:             DomainManager = new EntityDomainManager<TodoItem>(context, Request, Services);
 8:         }
 9:  
 10:         // GET tables/TodoItem
 11:         public IQueryable<TodoItem> GetAllTodoItems()
 12:         {
 13:             return Query();
 14:         }
 15:  
 16:         // GET tables/TodoItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
 17:         public SingleResult<TodoItem> GetTodoItem(string id)
 18:         {
 19:             return Lookup(id);
 20:         }
 21:  
 22:         // PATCH tables/TodoItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
 23:         public Task<TodoItem> PatchTodoItem(string id, Delta<TodoItem> patch)
 24:         {
 25:             return UpdateAsync(id, patch);
 26:         }
 27:  
 28:         // POST tables/TodoItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
 29:         public async Task<IHttpActionResult> PostTodoItem(TodoItem item)
 30:         {
 31:             TodoItem current = await InsertAsync(item);
 32:             return CreatedAtRoute("Tables", new { id = current.Id }, current);
 33:         }
 34:  
 35:         // DELETE tables/TodoItem/48D68C86-6EA6-4C25-AA33-223FC9A27959
 36:         public Task DeleteTodoItem(string id)
 37:         {
 38:             return DeleteAsync(id);
 39:         }
 40:     }
 41: }

En el ejemplo que nos viene, observamos cómo hay una clase base TableController que ya nos trae implementado de forma sencilla el acceso a datos gracias a la clase EntityDomainManager. Con lo que podemos utilizar esta clase base, o utilizar directamente Entity Framework o cualquier otro ORM.

Con este controlador, ya tendríamos disponible con Mobile Services la tabla TodoItem con las operaciones GET, POST, UPDATE y DELETE.

Para crear nuevos controladores simplemente necesitamos crear el modelo como esta creado TodoItem. Añadir al contexto de acceso a base de datos un nuevo DbSet del tipo de datos del modelo creado y por último crear el controlador para el modelo.

Publicando nuestro código

Por último solo nos falta publicar nuestro código a Mobile Services. Para ello lo único que tenemos que hacer es descargar nuestro perfil de publicador, que lo podemos encontrar en el Dashboard de nuestro Mobile Services.

clip_image002[4]

Una vez tenemos nuestro perfil de publicador, directamente desde Visual Studio podemos importar este y publicar directamente nuestro Servicio. Para ello tenemos hacemos botón derecho en la solución y elegimos publish:

clip_image003

clip_image005

Si todo ha ido correctamente, nos tiene que abrir el navegador y mostrar una pantalla similar a la siguiente:

clip_image007

Haciendo peticiones a nuestra API

Acceder a nuestro Mobile Services desde nuestras aplicaciones no ha cambiado con respecto tener el backend en Javascript, con lo cual nuestras Apps no verán diferencia entre uno u otro. Por esta razón podemos seguir utilizando la misma librería cliente de Mobile Services para acceder a todos nuestros servicios sobre Mobile Services ya estén en Javascript o en .NET.

Aunque si vamos a ver cómo podemos realizar una petición HTTP directamente usando Fiddler. Tenemos que recordar que para poder realizar peticiones a nuestro Mobile Services necesitamos la Application Key que podemos encontrar en nuestro dashboard. Esta clave tenemos que mandarla en la cabecera como X-ZUMO-APPLICATION. A continuación podemos ver un ejemplo:

clip_image008[4]

clip_image010

Montar nuestro servicio con backend .NET y desplegarlo sobre Mobile Service, como vemos es muy rápido y sencillo de realizar. Además tenemos la ventaja de poder extenderlo con todo lo que necesitemos ya que podemos utilizar toda la funcionalidad de Web API aprovechando la facilidad que nos aporta Mobile Service.

Carlos Carrillo Boj (3lcarry)