Delegate

Un delegate es un objeto que hace referencia a uno o más métodos, previamente declarados en nuestra aplicación. Todos aquellos métodos que sean incluidos en él, tienen la particularidad de ser idénticos en cuanto al retorno y los parámetros que recibe. ¿Con todo esto qué quiero decir? ¿Cuál es el objetivo? La magia está en que, si nosotros creamos un delegate con una serie de métodos asociados, al llamar al mismo lanzará un método detrás de otro pasándole a cada uno de ellos el valor(es) con el que invocamos al delegate. Veamos un ejemplo:

delegate void Delegado(string cadena);

Si mi delegado es como el anterior, todos los métodos que contenga no deberán de retornar nada y necesitan como parámetro un string.
Esa sería la forma de declarar un delegado. Para continuar con el ejemplo, voy a crear dos métodos que cumplan las características del delegado (Esto es muy importante porque, de no ser así, lanzará una excepción).

public void Saludo(string cadena)
{
lblResult.Text += "Hola " + cadena;
}
public void Despedida(string cadena)
{
lblResult.Text += " Adios " + cadena;
}

La forma de asignar un método sería la siguiente:

protected void btnDelegado_Click(object sender, EventArgs e)
{
Delegado delegando = Saludo;
delegando += Despedida;
delegando(txtCadena.Text);
}

Para asignar el método Saludo, simplemente utilizo el símbolo = y, para añadir el método Despedida +=
Si quisiéramos eliminar en algún momento del delegado uno de los métodos, únicamente tendríamos que utilizar -= nombre_del_Metodo

¡Saludos!

Cliente JSON para WCF

En un post anterior, mostré como crear un servicio web con Windows Communication Foundation. Para consumir el mismo, vamos a crear un pequeño cliente JSON con JQuery.
Creamos un proyecto ASP.NET Web Application:

Antes de comenzar con nuestro código, necesitamos la librería de JQuery, la cual podemos obtenerla en este enlace. Una vez descargada, agregamos el archivo a nuestra solución.
Por otro lado, vamos a crear un nuevo archivo JScript, llamado JSON.js, donde implementaremos la funcionalidad que llamará a nuestro servicio y recogerá el resultado. Nuestro proyecto quedaría de la siguiente manera:


He utilizado la página Default.aspx para mostrar dos textbox para recoger los valores y dos botones con los que llamaremos al servicio.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="ClienteJSON._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Cliente JSON</title>
</head>
<body>
<div id="Calculos">
<div>
<div>
<label id="lblNumeroUno">
Introduce número:</label>
<input type="text" id="txtNumUno" />
</div>
<div>
<label id="lblNumeroDos">
Introduce otro número:</label>
<input type="text" id="txtNumDos" />
</div>
<div>
<input type="button" id="btnSumar" value="Sumar" />
<input type="button" id="btnRestar" value="Restar" />
</div>
</div>
</div>

<script type="text/javascript" src="jquery-1.3.2.js"></script>
  <script type="text/javascript" src="JSON.js"></script>

</body>
</html>

Por último, sólo nos quedaría llamar a nuestro servicio web y mostrar el resultado que nos aporta, en función de si queremos Sumar o Restar los número que introducimos a través de la interfaz. Abrimos el archivo JSON.js e introducimos lo siguiente:

$("#btnSumar").bind("click", function(e) {

var params = { "a": $('#txtNumUno').val(), "b": $('#txtNumDos').val() };

$.ajax({
type: "GET",
url: "http://localhost/WCF/Service.svc/json/Suma",
data: params,
contentType: "application/json; charset=utf-8",
dataType: "json",
success: function(msg) {
alert("Resultado Suma: " + msg.d.Result);
}
});
});


$("#btnRestar").bind("click", function(e) {

var params = { "a": $('#txtNumUno').val(), "b": $('#txtNumDos').val() };

$.ajax({
type: "GET",
url: "http://localhost/WCF/Service.svc/json/Resta",
data: params,
contentType: "application/json; charset=utf-8",
dataType: "json",
success: function(msg) {
alert("Resultado Resta: " + msg.d.Result);
}
});
});

La verdad es que, teniendo JQuery, es bastante simple realizar este tipo de funcionalidad. He utilizado el método Bind, para asignarles el evento a cada uno de nuestros botones. De esta manera, no tenemos que introducir ningún código de javascript en nuestro aspx. Más adelante me gustaría enfocarme más en la manera de funcionar de esta librería.

En el mismo sitio donde bindeamos el evento click a nuestro botón, creamos la función que se va a ejecutar.
Utilizamos la variable params para montar nuestra cadena de parámetros. Hay que tener en cuenta que el nombre de cada parámetro se debe corresponder con el que tienen en el servicio web (en este caso a y b).
Creamos un objeto ajax con los atributos type (el tipo de HTTP Verb que vamos a utilizar), la url donde se aloja nuestro servicio, seguido del método que vamos a invocar, en data le pasamos los parámetros necesarios para el cálculo solicitado, contentType indica cómo va a evaluar JQuery la respuesta y cómo nos la va a devolver (En el caso de JSON evalúa la respuesta como tal y nos retorna un objeto javascript), dataType es el formato en el que estamos pasando nuestro parámetros y en la parte success se adjunta la función que se lanzará cuando haya terminado el proceso en caso de éxito. En un principio, esto es lo mínimo que debemos usar.

Si arrancamos la aplicación, ya tenemos nuestra Suma y nuestra Resta funcionando con un servicio web en WCF y su cliente en JSON.

 
¡Saludos!

Actualización 31/10/2009: En el archivo JSON.js, he modificado la forma de recuperar el valor de los textbox por .val(), que sería la forma correcta con JQuery. De la otra manera, $(‘#textbox’)[0].value, era un híbrido que funciona exactamente igual, pero creo que queda más elegante con .val(). ¡Saludos!

Soporte Intellisense para JQuery en Visual Studio 2008

Por el momento, hasta que no podamos disfrutar del todo de Visual Studio 2010, la versión 2008 no tiene por defecto el soporte para el intellisense de JQuery. ¡Pero todo tiene solución! Ya que entiendo que es una gran comodidad para el programador visualizar las posibilidades que nos ofrece una librería como esta.
En primer lugar debemos tener instalado el SP1 para Visual Studio 2008 (o también, desde ese mismo link, podemos conseguir el Visual Studio 2008 Express Editions con el SP1 integrado)  y un hotfix que podéis descargar de esta dirección.
Una vez que tenemos listo nuestro Visual Studio, ya podemos descargar los vsdoc.js que nos ofrece JQuery. Si accedemos al listado de descargas, podemos visualizar los vsdocs disponibles desde la versión 1.2.6 en adelante. Los archivos necesarios son aquellos que en la descripción aparece lo siguiente: Visual Studio Autocomplete Documentation.

Descargamos el vsdoc para la versión que estamos utilizando de JQuery y lo agregamos en nuestro proyecto. Al comienzo de los archivos js, indicamos como referencia el vsdoc que hemos añadido de la siguiente forma:

/// <reference path="~/jquery-1.3.2-vsdoc2.js"/>

Por último, podemos comprobar como efectivamente nos muestra el listado de posibilidades y una pequeña descripción de el uso de las mismas.

¡Saludos!

System.InvalidOperationException IIS 7

En el post anterior, comentaba algunos comandos para poder solucionar los problemas que pudiéramos tener con nuestras aplicaciones con WCF y nuestro IIS. Con esos dos pasos, conseguí que funcionara perfectamente en Windows XP (IIS 5.1)… pero al llegar a casa y volver a ejecutar la aplicación en IIS 7 con Windows 7… Llega de nuevo la desilusión. El caso es que lo conseguí arreglar cuando tenía la versión de 32bits, pero me bajé la de 64bits y claro, para que voy a apuntarme este tipo de cosas 😉
El error que me mostraba era el siguiente:

Después de dar muchísimas vueltas, leer blogs, preguntar a Google de cuatrocientas formas distintas, etc. nada me sirvió y la verdad es que sigo sin entender bien por qué. El caso es que se me ocurre la genial idea de montarlo como Sitio web en vez de Directorio Virtual y ahora le parece estupendo.

 

La verdad es que no entiendo bien por qué no acepta el servicio como un directorio virtual, pero es la única forma en la que he conseguido que me funcionara con WCF en Windows 7 y la verdad no recuerdo si llegué a la misma conclusión cuando tenía instalada la versión de 32bits.
¿Alguien sabe otra solución o conoce la causa de esto? En cualquier caso, si a alguien le sucede lo mismo que a mí y no encuentra otra solución alternativa a esta, siempre nos quedarán los sitios web 🙂

¡Saludos!

Failed to access IIS metabase

  1. Siempre instalaré IIS antes que Visual Studio.
  2. Siempre instalaré IIS antes que Visual Studio.
  3. Siempre instalaré IIS antes que Visual Studio.
  4. Siempre instalaré IIS antes que Visual Studio.
  5. Siempre instalaré IIS antes que Visual Studio.
  6. Siempre instalaré IIS antes que Visual Studio.
  7. Siempre instalaré IIS antes que Visual Studio.
  8. Siempre instalaré IIS antes que Visual Studio.
  9. Siempre instalaré IIS antes que Visual Studio.
  10. Siempre instalaré IIS antes que Visual Studio.


Y si es que no… ¡A sufrir se ha dicho! Cada vez que formateo y tengo que organizar las extensiones del IIS me vuelvo loca para volver a lo que tenía configurado y pensé que nunca más volvería a sufrir. Este error pasa justamente por esto y, antes de volvemos locos de remate, abrimos una línea de comandos y ejecutamos lo siguiente:

%system root%Microsoft.NETFrameworkversionNumberaspnet_regiis.exe -i

Por ejemplo:

C:WINDOWSMicrosoft.NETFrameworkv2.0.50727>aspnet_regiis.exe -i

Sin irnos muy lejos, es posible que si justamente hemos instalado IIS después del Visual Studio, tampoco tengamos las extensiones svc  y nuestras aplicaciones WCF no funcionen. Os dejo también este otro comando para matar dos pájaros de un tiro:

C:WINDOWSMicrosoft.NETFrameworkv3.0Windows Communication Foundation>ServiceModelReg.exe -i


¡Suerte y Saludos! 

Creando un Web Service con WCF

Windows Communication Foundation fue una de las novedades de .NET Framework 3.0, la cual permite la creación de sistemas distribuidos orientados a servicios.
Con Visual Studio 2008, disponemos de una plantilla que nos genera todo lo necesario para empezar a trabajar con ello. No obstante, en esta ocasión, dejaremos de lado la misma para poder visualizar claramente qué es lo necesario para que WCF funcione.

CREACIÓN DEL PROYECTO

Creamos un nuevo proyecto de tipo librería:

Incluimos las librerías System.ServiceModel y System.Runtime.Serialization.

EL CONTRATO (CONTRACT)

Lo primero que debemos crear es una interfaz que tendrá como misión ser el Contrato del servicio web. Lo que nos indica el mismo es qué funcionalidades tiene operativas el servicio de cara a las aplicaciones que lo van a consumir.
Creamos una interfaz llamada IService.cs y codificamos las siguientes funcionalidades:

using System.ServiceModel;
using System.ServiceModel.Web;
using System.Runtime.Serialization;

namespace WCF
{
    [ServiceContract]
    public interface IService
    {
        [OperationContract]
        [WebGet]
        Resultado Suma(int a, int b);

        [OperationContract]
        [WebGet]
        Resultado Resta(int a, int b);
    }
   [DataContract]
    public class Resultado
   {
       [DataMember]
       public int Result { get; set; }
   }
}

Tenemos los siguientes atributos:

  • ServiceContract, el cual indica que nuestra interfaz va a hacer las veces de contrato.
  • OperationContract por cada método que queramos exponer.
  • Por último, dentro del mismo archivo (No es recomendable) hemos creado una pequeña clase con el atributo DataContract que será el objeto serializado que viajará como respuesta a las peticiones tanto de la Suma como la Resta. Por cada miembro dentro del contrato de datos, contiene un DataMember.

Es una clase perfectamente normal que contiene los métodos que definimos en el contrato. Si creamos código adicional, para realizar cualquier otra operación, no sería visible al no estar definido en la interfaz del servicio.

EL ARCHIVO SVC

Un archivo importante a tener muy en cuenta es el archivo con extensión svc, el cual erá de utilidad a IIS cuando publiquemos el servicio. Añadimos un documento en blanco, llamado Service.svc, con el siguiente contenido:

<%@ ServiceHost Service=”WCF.Service” %>

Le indicamos el namespace de la  implementación del contrato como valor de Service para que pueda localizarlo.

DLL FUERA DE DEBUG Y RELEASE

Para que IIS pueda localizar correctamente las librerías del servicio web, debemos cambiar las propiedades de Build en nuestro proyecto y dejar nuestro “Output path” de la siguiente forma:

Por último, quizás la parte más compleja, necesitamos configurar el archivo web.config con los endpoints necesarios para aceptar peticiones. Dependiendo de los distintos tipos de comunicacion que tengamos, deberemos implementar más o menos endpoints.

¿Qué es un Endpoint?

Un endpoint está compuesto por tres valores: Address (¿Dónde?), Binding (¿Cómo?) y Contract (¿Qué?). La suma de ellos genera una serie de requisitos para poder establecer una conexión con nuestro servidor. Un servicio con WCF puede disponder de varios endpoints distintos, por lo que el número de clientes de diferentes características pueden consumirlo.

Creamos pues un archivo Web.config y eliminamos el contenido. En este post, voy a crear un endpoint para un cliente JSON.

<?xml version=”1.0″?>
<configuration>
  <system.serviceModel>
    <bindings>
      <webHttpBinding>
        <binding name=”webBinding”>
        </binding>
      </webHttpBinding>
    </bindings>
    <services>
      <service name=”WCF.Service”
               behaviorConfiguration=”MiBehavior”>
        <endpoint address=”json”
                  binding=”webHttpBinding”
                  bindingConfiguration=”webBinding”
                  behaviorConfiguration=”jsonBehavior”
                  contract=”WCF.IService”/>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name=”jsonBehavior”>
          <enableWebScript/>
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name=”MiBehavior”>
          <serviceMetadata httpGetEnabled=”true”/>
          <serviceDebug includeExceptionDetailInFaults=”True”/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Dentro de la sección system.serviceModel tenemos:

Por un lado, la sección de los bidings disponibles, que en este caso sólo tenemos el necesario para una configuración de JSON; services donde indicamos el address, el nombre de nuestro binding, el behavior (indicado más abajo)  y el nombre del contrato que queremos utilizar.

Llegados a este punto, podemos crear una aplicación que tenga hosteado el servicio que acabamos de crear o bien utilizar IIS, configurando como documento de inicio Service.svc.

IMPLEMENTACIÓN DEL CONTRATO

El siguiente paso es crear una clase que implemente el contrato que acabamos de definir.

namespace WCF
{
    public class Service : IService
    {
        public Resultado Suma(int a, int b)
        {
            var resultado = new Resultado {Result = a + b};
            return resultado;
        }

        public Resultado Resta(int a, int b)
        {
            var resultado = new Resultado {Result = a – b};
            return resultado;
        }
    }

}

Si accedemos a las dos direcciones que indico abajo a través del explorador, debería devolvernos un archivo en formato JSON por cada petición.

http://localhost/WCF/Service.svc/json/Suma

http://localhost/WCF/Service.svc/json/Resta

Ambas devolverían cero porque no se les está pasando ningún parámetro.
En el siguiente post de WCF, crearé un cliente que realice y reciba la respuesta con JSON para poder acceder a nuestro servicio web y pasarle los parámetros necesarios.

¡Saludos!  

Reflector

En alguna ocasión, hemos necesitado conocer la forma de trabajar de un método de alguna librería en concreto. Tenemos dos formas de poder averiguarlo: Una es la imaginación 🙂 y la otra utilizar algún programa como Reflector. Resulta bastante útil para visualizar los métodos usados por muchas dlls del framework y otras aplicaciones. Podemos descargarlo de forma gratuita de la siguiente página:  www.red-gate.com/products/reflector/

Cuando arrancamos la aplicación, nos aparece una lista donde podemos elegir cuál es el framework que nos interesa cargar.


La interfaz de la aplicación no tiene mayor complejidad y vienen algunas dlls cargadas por defecto para el framework escogido.

Para visualizar el código, simplemente navegamos a través de las dlls y pulsamos  sobre la que nos interesa. En un principio, solamente vemos los prototipos de la clase que hemos seleccionado. Podemos mostrar los métodos simplemente pulsando en el link Expand Methods.

 

Por último, comentar que podemos añadir más librerías y mostrarlas en varios lenguajes como IL, C#, Visual Basic, Delphi, MC++ y Chrome.

Si alguien conoce más aplicaciones de este tipo, agradecería la contribución por si tienen más funcionalidad de la que reflector ofrece.

¡Saludos!

Acceder a SQL Azure con SQL Server Express 2008 Management Studio

Una vez que hemos conseguido activar nuestra cuenta de SQL Azure, comenzamos con la parte interesante: La creación y administración de las bases de datos.
Mientras la invitación de SQL Azure esté vigente, tenemos la posibilidad de crear cinco base de datos dentro del servidor que se nos ha asignado. En este caso, nada más entrar a http://sql.azure.com me he creado una base de datos Test. Hay que tener en cuenta que, para acceder después, debemos tener una contraseña que podemos resetear en la misma página. El usuario ya nos lo están facilitando.

Lo primero que se me ocurre hacer es intentar conectarme a mi nueva base de datos a través de SQL Server Express 2008 Management Studio introduciendo los datos que se me facilita en la página. En un principio, la suerte no está de mi lado:


Esto sucede cuando intentamos acceder a SQL Azure desde el cuadro de diálogo que aparece al inicio. Después de investigar en el foro creado para esta nueva tecnología, la solución que aportan por el momento es la siguiente:

1. Cerramos el cuadro de diálogo inicial de nuestro Management Studio.
2. Pulsamos sobre New Query (Nueva Consulta) y se volverá a abrir de nuevo un cuadro de diálogo para pedirnos los datos de conexión.
3. Introducimos nuestro Server Name, Server Admin (Login) y Password. El Server Name debe ser el que nos aparece en las cadenas de conexión que nos facilitan desde la página de SQL Azure. Para acceder a ellas, seleccionamos una de nuestras bases de datos y pulsamos el botón inferior de Connection Strings.

4. En la pestaña Connection Properties, escribimos el nombre de la base de datos a la que queremos conectar. En mi caso, será la base de datos Test.

5. Pulsamos en Connect y nos aparecerá un mensaje de error, aunque realmente es un warning.

A partir de ahora estamos conectados a nuestra base de datos. Resulta un poco incómodo por el hecho de no poder visualizar los objetos en el explorador. Aún así, podemos realizar cualquier tipo de consulta o administración a través de nuestra nueva ventana de consulta. Si yo escribo lo siguiente:

CREATE TABLE [Table_Test]
(
[id] int IDENTITY(1,1) NOT NULL
);
select * from Table_Test;


Y pulso F5, compruebo que efectivamente puedo comenzar a crear mis tables dentro de SQL Azure.

Por otro lado, cabe comentar que hay otra alternativa para conectarse y poder administrar nuestras bases de datos de una forma más visual. Se trata de de SQL Azure Manager y se puede acceder a través de este link.

¡Saludos!

Actualización 13/11/2009: Se han realizado los cambios pertinentes para esta incidencia. Estas modificaciones se pueden ver en el post Cambios en SQL Azure.

Subir una aplicación a Windows Azure

Versión Actualizada aquí

Una vez que tenemos agregado un servicio en Windows Azure, estamos preparados para subir nuestra aplicación a la nube. Normalmente, lo que debemos hacer, es subir la misma al entorno Staging y, una vez que hayamos realizado las pruebas oportunas, pasarla a producción para que nuestro servicio sea público.
Para trabajar con Windows Azure y Visual Studio necesitamos instalar una serie de complementos. Para acceder a ellos, nos dirigimos a www.microsoft.com/azure y pulsamos en el siguiente enlace:


En esta página se nos ofrecen una serie de links como las herramientas para Visual Studio, Windows Azure SDK y Microsoft .NET Service SDK. Haremos clic en cada uno de los enlaces para instalar los mismos.


Cuando finalicemos las instalaciones, abrimos nuestro Visual Studio, File => New => Project … y deberíamos tener una nueva plantilla llamada Cloud Service.

Cuando pulsamos OK, nos aparece una nueva ventana con tres tipos de proyectos más:

  • ASP.NET Web Role : Es una aplicación Web  estándar, preparada para funcionar en Windows Azure.
  • Worker Role: Es una aplicación que se ejecuta en segundo plano, como un servicio Windows, para Windows Azure.
  • CGI Web Role: Este proyecto se utiliza para correr aplicaciones FastCGI.

Seleccionamos ASP.NET Web Role y, a través los botones que aparecen en el centro,  añadimos la selección a la parte derecha de la ventana, modificando su nombre por Movies.WebRole.


A partir de este momento, tenemos dos proyectos en nuestra solución:

CloudService contiene la referencia de Movies.WebRole y además dos archivos necesarios para Windows Azure: ServiceConfiguration.cscfg, el cual incluye la configuración de nuestro servicio, instancias que tiene, etcétera y ServiceDefinition.csdef que contiene la metadata necesaria para que Windows Azure entienda cual es la forma de trabajar nuestra aplicación (En este archivo aparecen los roles de nuestra aplicación, endpoints, etc.)

Como realmente no me quiero extender en lo que es la codificación de un programa nuevo, únicamente voy a incluir un texto en el Default.aspx de Movies.WebRole, ya que solo quiero mostrar la forma de subir la aplicación a la nube.

   1: <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Movies.WebRole._Default" %>
   2:  
   3: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
   4: <html xmlns="http://www.w3.org/1999/xhtml" >
   5: <head runat="server">
   6:     <title>Testing Windows Azure</title>
   7: </head>
   8: <body>
   9:     <form id="form1" runat="server">
  10:     <div>
  11:     Tutorial de Windows Azure desde <a href="http://returngis.blogspot.com/">Return(GiS);</a>
  12:     </div>
  13:     </form>
  14: </body>
  15: </html> 


Si pulsamos F5 para probar en local la misma, nos encontraríamos con este mensaje:

Lo único de lo que nos está advirtiendo es que Development Fabric necesita ser iniciado para poder arrancar este tipo de aplicación en local y que necesita que nuestro Visual Studio esté abierto con credenciales de administrador. Entonces, cerramos Visual Studio, hacemos clic sobre el icono del mismo y pulsamos sobre “Ejecutar como administrador”. Abrimos nuestra aplicación de nuevo y al pulsar F5 nos aparecerá un cuadro de diálogo distinto, preguntando si puede iniciar Development Storage con credenciales de Administrador.

Cuando damos permiso, aparecerá una nueva ventana donde nos informa de la inicialización de Development Storage y la instancia de SQL Server que está usando.


La aplicación arranca y dos iconos aparecen en nuestra barra de tareas:

Development Fabric es una interfaz de administración, donde podemos ver nuestro servicio, las instancias que tiene a su disposición y la consola del mismo.


Y, por otro lado, Development Storage:

Esta otra herramienta, depende de una instancia de SQL Server y se utiliza para el almacenamiento. En este caso, no es necesario Development Storage ya que no necesitamos almacenar absolutamente nada.

Sin entrar en más detalles por el momento, ha llegado la hora de publicar nuestra pequeña aplicación en la nube. Como si se tratara de una aplicación cualquiera, seleccionamos CloudService con el botón derecho y seleccionamos Publish…
Al hacer esto, ocurren dos cosas: Nos abre una ventana de nuestro explorador web que nos envía al portal de Azure y una ventana del explorador de Windows en la ubicación donde se encuentran los archivos que tendremos que subir.

En el explorador web, seleccionamos nuestro proyecto, hacemos clic en el servicio que tenemos preparado para nuestra aplicación y en el apartado Staging hacemos clic en el botón Deploy.
Se nos piden dos archivos: Aplication Package (CloudService) y Configuration Settings (ServiceConfiguration). Añadimos cada uno en su lugar, indicamos una etiqueta para este deploy  y pulsamos en el botón Deploy.
Aparecerá una ventana en blanco durante unos instantes y volveremos a la página de nuestro Servicio con la siguiente imagen:

Si ahora mismo pulsamos en la URL que nos ofrece, no funcionará ya que el servicio aún no está iniciado. Para ello, pulsamos en el botón Run.

Una vez que finalice, cambiará el estado a Initializing, el cual puede tardar un tiempo en cambiar a Started que es el que nos indicará que nuestra aplicación está lista para acceder en el entorno de Staging.


Ahora ya podemos probar en nuestro entorno de Staging de Windows Azure, sin necesidad de tenerlo públicamente en Internet. Cuando creamos que esté listo, es tan fácil como pulsar el botón de sincronización central y la nube se encargará de realizar el trabajo por nosotros.


Cuando realizamos la sincronización, nuestro entorno de Staging recupera la versión que estaba subida anteriormente en Producción, si es que existía alguna, y nuestra URL pública queda habilitada con nuestro nuevo servicio.

¡Saludos!

Extension Methods

Una de las nuevas funcionalidades de C# 3.0 fue la
posibilidad de ampliar los métodos de una clase ya existente. Con ello,
conseguimos aprovechar al máximo las clases ya predeterminadas, añadiéndole
alguna funcionalidad que nos es requerida para nuestra aplicación. De no ser así,
deberíamos tener estos métodos en clases distintas y perderíamos esa
unificación.

He recuperado un pequeño ejemplo de msdn, donde añadimos un nuevo método a la
clase String con el que podemos contar las palabras de una cadena.

Para ello, he creado un proyecto web con un texbox y un botón. Añado un
proyecto de tipo librería para almacenar mi clase “Extensions” dónde
especifico el nuevo método que agregaré a esta clase. De esta manera puedo utilizar mis extensiones en cualquier otro proyecto que lo necesite.

using System;

namespace Extensions
{
public static class Extensions
{
public static int ContarPalabras(this String str)
{
return str.Split(new[]{'','.','?'}, StringSplitOptions.RemoveEmptyEntries).Length;
}
}
}


Como podemos ver, creamos un método con el nombre que queremos que aparezca
dentro de nuestra clase. Como parámetros (aquí está la clave) le indicamos que
este método (this) pertenece a la clase String.
El contenido del mismo es exactamente igual que cualquier otro método. En este caso,
lo único que hacemos es crearnos un array, a raíz de un split realizado a la
cadena que está instanciada en nuestra clase String, y retornamos el tamaño de
ese array, omitiendo los blancos.
Importamos la librería a nuestro proyecto web y, si nos creamos un String y
comprobamos la lista de posibilidades nos aparecería lo siguiente:


Para comprobar esta funcionalidad, defino un evento click para mi botón y recojo la cadena introducida por el usuario para comprobar su tamaño.

using System;

namespace ExtensionMethod
{
public partial class Default : System.Web.UI.Page
{
protected void btnContar_Click(object sender, EventArgs e)
{
string cad = txtCadena.Text;
lblResult.Text = string.Format("La cadena tiene {0} palabras", cad.ContarPalabras());
}
}
}


 
¡Saludos!