Aunque es un tema que parece nuevo, la Virtualización tiene muchos años, quizás décadas, de estudios para ser lo que es ahora.

Pero, en realidad que es? Para qué sirve?

Cuando nos referimos a Virtualización hacemos referencia a agrupar los recursos informáticos en equipos virtuales de forma que los usuarios no aprecien la naturaleza física y los limites de dichos recursos. De forma resumida, la Virtualización es la anulación de la dependencia del software con respecto al hardware.

Para tener una idea de lo que es Virtualización debemos conocer algunos procesos, entre ellos tenemos Virtualización mediante hipervisor o en otras palabras Monitor de equipo virtual. Aquí la Virtualización de los equipos se consigue mediante una capa de software denominada “monitor del equipo virtual” que se sitúa entre el sistema operativo y el hardware. Dicha capa proporciona acceso a los recursos de hardware y permite ejecutar varios sistemas operativos distintos en una sola maquina o servidor (host).

Actualmente dos tipos de Virtualización han sacudido los entornos de datos, hasta ganarse el respeto en el tema.

• El primero de ellos es conocido como Virtualización total, donde el hardware o el software (o una combinación de ambos) simulan una plataforma completa con el fin de permitir la ejecución de un sistema operativo sin modificaciones. Usando este método no es necesario personalizar el sistema operativo invitado. Sin embargo, como el sistema operativo se ha diseñado para su funcionamiento en hardware físico, éste no detecta el monitor del equipo virtual, ya sea en forma de hipervisor o de solución de host. Como resultado, el equipo virtual no podrá colaborar con otros para compartir recursos y mejorar el rendimiento.
  

• El segundo Paravirtualización, al contrario de lo que ocurre con la virtualización total, en este se simula el hardware sólo de forma parcial. Este término hace referencia a las modificaciones realizadas en un sistema operativo con el fin de mejorar el rendimiento en entornos virtuales. El hipervisor colabora con las API que permiten abstraer los recursos de hardware del equipo virtual. Para que la paravirtualización funcione es preciso modificar las partes del sistema operativo invitado que dependan del hardware de modo que éstas detecten la capa de virtualización. El hipervisor evita las instrucciones del procesador difíciles de llevar a cabo en un entorno virtual y las sustituye por una llamada de procedimiento que proporciona esa función. De este modo, los equipos paravirtuales suelen rendir mejor que los equipos con virtualización total. La paravirtualización está ganando cada vez mayor popularidad debido a que se obtiene un mejor rendimiento con los chips existentes. Además, ofrece grandes ventajas en combinación con la última generación de chips x86 compatibles con la virtualización como los dispositivos Intel* VT y AMD-V. Asimismo, permite compartir la memoria conjunta entre equipos sin modificar el sistema operativo host.
  

El tema de Virtualización es un poco difícil y profundo pero no es imposible de entender, lo digo por experiencia, ya que escuche por primera vez de esto hace algunos meses y desde entonces he leído mucho de él pero claro está que no soy ningún especialista.

Bueno entonces sigamos,

La Virtualización en opinión personal es muy importante hoy debido a la gran variedad de sistemas operativos (SO) que existen tanto de Software Propietario como de Software Libre, y existe la posibilidad de probar varios de ellos por decirlo de algún modo, al mismo tiempo, además de este punto la forma en que se pueden reducir los costos en las empresas también da un punto a favor para la utilización del mismo.

Cuando probé por primera vez lo que era en realidad virtualizar, lo hice en una máquina no tan potente y logre correr sobre Windows Vista Ultimate 3 maquinas virtuales gracias a las bondades de Virtual PC 2007, entre ellas estaba Windows XP Professional Service Pack 2, Ubuntu 7.10 y Windows Server 2008. La experiencia fue muy buena ya que puedes interactuar con no solo un SO sino con tres, puedes compartir el hardware utilizando quizás la unidad de CD, un puerto USB, etc.

A pesar de que solo he hecho utilización de la virtualización para pruebas sencillas de Sistemas Operativos, una de las muchas utilidades que tiene la virtualización es usarla en la parte de servidores.

Algunos de Los beneficios de la virtualización que pueden experimentar los clientes por su implementación:

• Aumentar la utilización de los servidores. Al facilitar la consolidación de las aplicaciones y los servidores físicos, la virtualización permite utilizar los recursos de hardware de forma más eficaz y, por tanto, reducir los costos inmobiliarios, de electricidad, mantenimiento y hardware.

• Aumentar la continuidad empresarial y el tiempo de actividad del sistema. Los clientes pueden reducir los riesgos que entrañan los períodos de inactividad imprevistos mediante la migración de cargas de trabajo heterogéneas a equipos virtuales y la consiguiente migración de estos sistemas virtuales a equipos físicos distintos.

• Aprovechar el exceso de capacidad del centro de datos y mejorar los tiempos de respuesta. Al equilibrar las cargas informáticas en los recursos de los centros de datos durante las horas de mayor actividad, el funcionamiento de los equipos resultará más eficaz y rentable.

• Redistribuir los recursos de servidores físicos. Gracias a la virtualización, los clientes podrán migrar cargas de trabajo de servidores a redes virtuales y liberar recursos físicos que se pueden quitar o redistribuir para otros usos.

• Ofrecer portabilidad y flexibilidad de aplicaciones a las plataformas de hardware. Las aplicaciones se pueden ejecutar en cualquier hardware capaz de adoptar la abstracción propia de la virtualización.

• Mejorar la productividad en tareas administrativas y la capacidad de respuesta. La virtualización permite que las empresas de TI mejoren la productividad en tareas administrativas e implanten nuevos servidores de forma rápida y sistemática con el fin de adaptarse a las cambiantes necesidades empresariales.

En el centro de datos, la virtualización es una tendencia en alza ya que las nuevas tecnologías cuentan con el potencial necesario para solucionar los problemas relacionados con la eficacia, la capacidad de ampliación, la facilidad de administración y el aprovechamiento de los recursos. Provistos de equipos virtuales, los administradores de los centros de datos pueden crear nuevos niveles de flexibilidad y agilidad en sus entornos con un costo total de la propiedad menor.

La virtualización puede mejorar el aprovechamiento de los recursos en servidores individuales y, de este modo, economizar aún más esas inversiones. Además, permite la integración de sistemas distribuidos, gracias a que un conjunto heterogéneo de servidores de cálculo y almacenamiento se transformaría en una auténtica plataforma informática empresarial.

Mi recomendación hoy es implementar la virtualización, háganlo solo por pruebas con dos o tres sistemas operativos, además recomiendo que si tienes Windows® instales en tu máquina Microsoft® Virtual PC 2007 que es la herramienta que nos permite virtualizar localmente los sistemas que queramos, incluso cabe destacar que dicha herramienta es gratuita desde la página de Microsoft®.

Microsoft anunció que el Service Pack 1 (SP1) del Windows Vista, a lanzarse durante el primer trimestre de 2008, frenará los dos métodos más utilizados por los piratas informáticos para hacer copias ilegales del sistema operativo.

En primer lugar, corregirá una vulnerabilidad vinculada al BIOS de la motherboard, que permite a los piratas simular el proceso de activación que utilizan algunos fabricantes de computadoras para instalar Vista en las computadoras que comercializan.

En segundo lugar, añadirán medidas para impedir las técnicas aplicadas a extender, de manera ilimitada, el “periodo de gracia” que otorga la compañía entre la instalación y la activación del Vista.

Microsoft también cambiará la forma de tratar las versiones pirateadas del nuevo Windows. En la actualidad, cuando se detecta una copia ilegal o no se lo activa a tiempo, el sistema operativo queda limitado en funciones.

Con el SP1, los usuarios recibirán ahora notificaciones periódicas de que su versión del software es fraudulenta, con un enlace para comprar una copia auténtica.

Según el grupo empresarial Business Software Alliance, en torno al 35 por ciento del software para usuarios del mundo está pirateado. Windows, presente en más del 90 por ciento de las computadoras del mundo, es el producto que más se copia ilegalmente.

Al finalizar septiembre, la empresa había vendido 88 millones de licencias de Vista. Las mejoras para reducir la piratería implementadas en el sistema operativo lograron incrementar en un 25 por ciento las ventas de Windows durante el tercer trimestre del año.

Venezuela y su mencionado cambio de Horario!!!!! 

El 9 de diciembre a las tres de la madrugada se implementará de manera oficial la nueva hora legal en Venezuela, la cual se aplicará retrasando los relojes media hora.

Donatella Pizzi de Machado, corredactora de la Ley de Metrología Explicó que el meridiano escogido es más céntrico al país. “Esas decisiones hay que tomarlas en su globalidad porque vivimos en un país con conexiones internacionales; entonces no es solamente la posición que tiene, sino lo que implica lo que es un sistema horario internacional, en el cual se procura tener horas enteras para el mejor manejo de las horas bajo todo aspecto de vista, comunicacional, comercial y económico”.

Indicó que a su vez salimos de la alineación que teníamos con cinco países “lo cual nos conviene comercialmente hablando del continente”. Destacó que en la Gaceta Oficial ya está establecido el Meridiano 67º 30’, el cual es el mismo que tenía Venezuela en 1912.

Manifestó que desde que se elaboró la propuesta, hasta el momento en que se va a implementar ha habido una serie que restricciones y de cambios convenientes; sin embargo considera que “son demasiados cambios para los efectos reales que va a tener esta medida, demasiados ajustes a líneas aéreas, ajuste de maquinarias, entre otros cambios”.

Por otra parte el ministro del Poder Popular para Ciencia y Tecnología, Héctor Navarro. Su señalamiento lo hizo este viernes al ser entrevistado en Venevisión. Explicó que se trata de una medida que tiene que ver con la salud pública, ‘por lo que todos tenemos que tener un mínimo de racionalidad al respecto y acatarla”. Este domingo 9/12, a las 3:00 de la mañana, con motivo del cambio de la hora legal de Venezuela los relojes deberán retrasarse media hora. No obstante, Navarro señaló que no es necesario que los venezolanos se levanten a esa hora para retrasar el reloj, con que lo hagan al levantarse el domingo es suficiente. Hizo la salvedad de que quienes sí deben hacerlo a esa hora son los que llevan la hora legal de Venezuela en el Observatorio Cagigal, porque tienen una responsabilidad internacional, así como los que tienen que ver con los prestadores de servicios de telefonía.

 Asi que no se preocupen por retrasar sus relojes el domingo en la madrugada, cuando despierten en la mañana o al mediodia o incluso en la noche (ya que hay personas que duermen todo el dia) pueden hacerlo. Recuerden quitenle 30 minutos y listo!

Ultimamente se ha venido escuchando en nuestro país algo de un cambio de horario parece ser que se le restara 30 minutos a la hora normal, según esto empezaria a partir del 1 de octubre pero tambien escuche a un amigo diciendo que ya ese cambio no se realizara.

Bien sea o no el caso ya que no es mi objetivo hablar de si el Gobierno cambia o no, El Presidente lo anunció y lo que se queria hacer era un cambio a la zona horaria para el país el cual hasta fecha normalmente que habia observado Hora estándar de Occidental de Sudamérica. Según informes oficiales, aún hay una fecha de comienzo de zona horaria nueva para determinarse pero proyectarse para producir antes de 31 de diciembre de 2007.

Debido a ese alboroto, Microsoft publicó una actualización para el sistema operativo Windows (Windows XP, Windows Server 2003 y Windows Vista) que ya está disponible para permitir que pruebe y que implemente la zona horaria nueva para Caracas, Venezuela antes de un anuncio oficial de la fecha de moverse a la zona horaria nueva a clientes y socios.
Al mover a sus clientes Windows a la zona horaria nueva, se moverán relojes de atrás 30 minutos de UTC –4 : 00 a UTC –4 : 30. Este cambio se comienza en hora local 11:59:59 p.m. en la fecha de comienzo. Los relojes deberían estar movidos de nuevo a 11:30:00 p.m. en vez de que debido avanzar a 12 :00:00 AM (medianoche).

Microsoft recomienda que los clientes que actualizan manualmente su información de zona horaria utilizando esta actualización mantengan sus configuraciones de zona horaria actual y que confirmen la fecha de comienzo del cambio de zona horaria en el República de Venezuela Bolivariana antes de utilizar la zona horaria nueva.

Usuarios finales pueden realizar esta actualización. La zona horaria nueva resultante puede permanecer en la ficha de zona horaria puede tener un nombre para mostrar de la Paz (GMT-04:00) hasta que el usuario haga una transición a Hora estándar de Venezuela manualmente. También esta zona horaria es Hora estándar de Occidental suramericana.

Utilizar esta zona horaria nueva antes que el cambio de zona horaria oficial afecte a la fecha y al tiempo en su equipo.

Bueno en realidad no estoy seguro si en realidad cancelaron el cambio de horario pero ya Microsoft se adelanto a esa desición y ya tenemos una zona horaria para Venezuela.

Fuente: http://support.microsoft.com/kb/938977

.NET Framework

La API principal contiene clases compartidas por todos los tipos de aplicaciones de .NET Framework 3.0.

Forman parte en gran medida del espacio de nombres System, así como de los descendientes tal como System.Collections. Las API de .NET Framework incluyen compatibilidad con:

.NET Framework también proporciona compatibilidad para crear aplicaciones Web y para Windows.

ASP.NET es una plataforma Web unificada que proporciona todos los servicios necesarios para generar aplicaciones Web de clase empresarial. Las clases que constituyen la API forman parte en gran medida del espacio de nombres System.Web o sus descendientes.

Windows Forms es una plataforma para desarrollar aplicaciones de cliente Windows. Una aplicación de Windows Forms también puede actuar como interfaz de usuario local en una solución distribuida de varios niveles. Windows Forms amplía la API principal con un claro conjunto orientado a objetos extensible de clases que permiten desarrollar aplicaciones avanzadas de cliente Windows. Las clases que constituyen la API forman parte en gran medida del espacio de nombres System.Windows.Forms o sus descendientes.

Microsoft® Windows® Communication Foundation

Windows Communication Foundation es la nueva infraestructura de comunicación orientada a servicios creada sobre la base de protocolos de servicios Web. La compatibilidad del servicio Web avanzado en Windows Communication Foundation proporciona una mensajería interoperable, segura, confiable y por transacciones.El modelo de programación orientado a servicios de Windows Communication Foundation se basa en .NET Framework y simplifica radicalmente el desarrollo de sistemas conectados. Unifica una amplia gama de capacidades de sistemas distribuidos en una arquitectura extensible que se puede componer y que admite varios transportes, patrones de mensajería, codificaciones, topologías de red y modelos de hospedaje. Es la nueva versión de varios productos existentes: Los métodos Web de ASP.NET (“ASMX”) y Microsoft Web Services Enhancements para Microsoft .NET (WSE), .NET Remoting, Enterprise Services y System.Messaging.

Las clases que constituyen la API de Windows Communication Foundation forman parte en gran medida del espacio de nombres System.ServiceModel y sus subespacios de nombres. Windows Communication Foundation admite una gran variedad de escenarios, que incluyen:

Microsoft® Windows® Presentation Foundation

Windows Presentation Foundation es un subsistema de presentaciones unificado de Microsoft para Windows. Consta de un motor de visualización y un conjunto de clases administradas que permite crear aplicaciones avanzadas y sensacionales visualmente. Windows Presentation Foundation también introduce XAML, que permite utilizar un modelo basado en XML para manipular mediante declaración el modelo de objetos de Windows Presentation Foundation.

Las clases que constituyen la API forman parte en gran medida del espacio de nombres System.Windows.Forms o sus descendientes. Los componentes principales son:

Microsoft® Windows® Workflow Foundation

Windows Workflow Foundation es una nueva plataforma de desarrollo de flujo de trabajo basada en .NET Framework.

Windows Workflow Foundation proporciona un modelo de programación para desarrollar y ejecutar una amplia variedad de aplicaciones de flujo de trabajo persistentes, con estado y de larga duración.

Windows Workflow Foundation proporciona una funcionalidad de flujo de trabajo de fábrica para desarrollar fácilmente aplicaciones basadas en flujo de trabajo como, por ejemplo, administración de documentos, flujo de páginas comerciales, administración de IT y distintas aplicaciones de línea de negocios.

Las aplicaciones pueden cargar el motor de flujo de trabajo y conectar una gran variedad de componentes del servicio de tiempo de ejecución. Windows Workflow Foundation es muy extensible, por lo que puede crear sus propios componentes personalizados para tratar preocupaciones empresariales concretas.

Windows Workflow Foundation también ofrece compatibilidad con ASP.NET para facilitar la creación y ejecución de flujos de trabajo que se ejecutan en el entorno de Internet Information Services (IIS)/ASP.NET.

Nota: El SDK de Windows^®, que incluye contenido para Microsoft® .NET Framework 3.0, proporciona un conjunto de interfaces de programación de aplicaciones (API) administradas, documentación, muestras y herramientas que permiten crear una gran variedad de aplicaciones para Windows. En un nivel superior, .NET Framework 3.0 consta de estos componentes básicos.

Fuente: http://www.microsoft.com/spanish/msdn/articulos/

Gracias a la disponibilidad de Windows Workflow Foundation (WF), Microsoft está introduciendo funciones de flujo de trabajo en la plataforma de desarrollador de .NET. Estas capacidades permiten que los desarrolladores creen flujos de trabajo que se ajusten a un amplio número de situaciones, desde sencillos flujos de trabajo secuenciales hasta complejos flujos de trabajo basados en equipos con sofisticadas interacciones humanas. Al mismo tiempo, se está imponiendo una tendencia que promueve la exposición de las funciones empresariales a través de extremos de servicio encapsulados, que permiten reutilizar y componer las funciones y los procesos empresariales, lo que provoca el ascenso de las arquitecturas orientadas a servicios. Windows Communication Foundation (WCF) está disponible ya para proporcionar a los desarrolladores funciones que permitan desarrollar sistemas conectados de forma sencilla, mediante una API de desarrollador consistente, un tiempo de ejecución de alojamiento sólido y una solución flexible controlada por configuración para asistir en la implementación.

Muestra de informes de gastos

La muestra de código de este artículo está basada en la muestra del flujo de trabajo de informes de gastos que funciona como modelo del proceso empresarial estándar relacionado con el envío y la aprobación de una reclamación de gastos por parte del empleado. La muestra original se ha actualizado para demostrar cómo se puede aprovechar de WCF y .NET 3.0 Framework para alojar este supuesto de forma más eficaz.

Cuando se publicó la primera muestra de informes de gastos, se utilizó .NET Remoting para ofrecer comunicación entre las aplicaciones cliente y la aplicación host que contenía la instancia de tiempo de ejecución del flujo de trabajo.

Hemos refactorizado la implementación de los informes de gastos para realizar la comunicación entre clientes y servicio mediante WCF. La solución también se ha estructurado lógicamente para apartar las distintas preocupaciones dentro de ésta.

Figura 1. Estructura de nuestra solución refactorizada

Es importante entender cómo se utilizan los mensajes dentro del contexto del proceso empresarial, de forma que pueda incorporarlos a su diseño. En el ciclo de vida de los informes de gastos, existen varios puntos de interacción. Revisémoslos brevemente:

Mediante WF, podemos modelar este proceso a través de las actividades estándar que se ofrecen con el marco. Podemos utilizar DelayActivity para administrar un desencadenamiento de eventos después de que haya transcurrido un período de tiempo y podemos utilizar el motor de reglas y PolicyActivity para administrar un conjunto flexible de reglas que se interroguen en busca de un resultado.

Dado que se trata de un proceso orientado al usuario, debemos interactuar con los usuarios finales y volver a desencadenar la interacción en el flujo de trabajo. WF ofrece un modelo de programación completo que permite la comunicación entre un host y un flujo de trabajo a través de los servicios locales, HandleExternalEventActivity y CallExternalMethodActivity.

Dado que esto supone un concepto importante en la creación de flujos de trabajo interactivos, analicemos rápidamente cómo se ha diseñado esto en WF.

Para modelar interacciones en WF, debemos diseñar un contrato que exponga un número de eventos y métodos. Tanto el proceso de host como el de flujo de trabajo comprenderán este contrato. El contrato/La interfaz que hemos creado se deben marcar con el atributo [ExternalDataExchange()], que los identifica como diseñados para el intercambio de datos de flujo de trabajo. En nuestra muestra, utilizamos la interfaz IExpenseLocalService con nuestro flujo de trabajo.

A continuación, suscribimos una clase (conocida como Servicio local) que implementa dicha interfaz con el tiempo de ejecución del flujo de trabajo. Las actividades de flujo de trabajo pueden registrarse para eventos o consumir métodos definidos en el tipo de interfaz, y se transmitirán al servicio local que hemos registrado. Esto utiliza un patrón denominado Inversión de control que elimina el estrecho acoplamiento entre el flujo de trabajo y el tipo concreto de servicio local. En nuestro ejemplo, la clase ExpenseLocalService implementa nuestro contrato IExpenseLocalService.

Si el flujo de trabajo se ejecuta primero, se puede ofrecer una bolsa inicial de datos en la que trabajar. Después de que el flujo de trabajo alcance un punto en el que necesite interacción externa, podemos desencadenar un evento que se pueda enlazar a HandleExternalEventActivity en el flujo de trabajo. Esta actividad toma el tipo de interfaz y el evento como argumentos. El flujo de trabajo se activará cuando se desencadene el evento, lo que permite que continúe la ejecución.

Si el flujo de trabajo debe volver a llamar a un servicio local, puede hacerlo mediante CallExternalMethodActivity y proporcionando la interfaz y el nombre de método como argumentos.

Gracias a estas actividades, podemos establecer una comunicación bidireccional dentro del proceso de host con un flujo de trabajo en ejecución y, a través del uso de la Inversión de control dentro de WF, se le protege del estrecho acoplamiento entre los flujos de trabajo y los servicios locales.

Sin embargo, y aunque son más extensas que el proceso de host, debemos permitir interacciones controladas por otros sistemas o incluso por otros usuarios. Podemos lograr este nivel de interacción distribuyendo nuestras operaciones interactivas a través de servicios a los que pueden, a su vez, llamar otros servicios o aplicaciones controladas por usuario. WCF es el marco en el que podemos crear esta función de mensajería de una manera flexible.

Las ventajas clave de nuestro supuesto de integración con WCF son las siguientes:

Lista de comprobación de integración

Para completar una integración de WF y WCF, debemos exponer una interfaz de servicio que ofrezca varios puntos de interfaz a los consumidores, donde puedan iniciar o interactuar con un flujo de trabajo en ejecución. El servicio se debe modelar en torno a los puntos en los que el proceso empresarial interactúa con entidades externas, como usuarios implicados en el proceso.

Figura 2. Puntos de interacción en el supuesto de informes de gastos

Para lograr esto, debemos:

Además de simplemente recibir nuestro flujo de trabajo, también podemos usar los canales dúplex de WCF para desencadenar eventos fuera del flujo de trabajo y devolverlos a los clientes de consumo. En el caso de los informes de gastos, esto supone una ventaja, ya que la solución depende de que los clientes sondeen el servicio en busca de actualizaciones de datos regulares. En vez de eso, pueden recibir la notificación directamente desde el servicio.

Para ello, debemos:

Definición de contratos de servicio

Windows Communication Foundation (WCF) requería que se declarara un contrato formal para definir de manera abstracta las funciones de un servicio y el intercambio de datos. Esto se define en código mediante la declaración de una interfaz.

Cuándo diseñe un servicio empresarial, probablemente utilizará un patrón de colaboración de solicitud y respuesta. Al utilizar este patrón, debe incluir estos tres aspectos en el contrato que se ofrece:

Un contrato de servicio se define mediante el uso de un marcado basado en atributos que defina los contratos que exponen operaciones y, a continuación, las operaciones específicas que se están publicando a través de la red.

Cada contrato de servicio se marca explícitamente con el atributo [ServiceContract]. Este atributo se puede declarar con parámetros entre los que se incluyan:

Declaración de operaciones

Por tanto, el servicio está compuesto de un número de operaciones publicadas. Las operaciones explícitamente suscritas en el contrato que se está marcando con el atributo [OperationContract]. Al igual que ServiceContract, un OperationContract tiene varios parámetros que controlan cómo se puede enlazar con un extremo. Éstos incluyen:

Aquí se incluye un ejemplo del aspecto de un contrato de servicio en el código.

[ServiceContract]
public interface IExpenseService
{
        [OperationContract]
        GetExpenseReportsResponse GetExpenseReports(); 

        [OperationContract]
        GetExpenseReportResponse GetExpenseReport(GetExpenseReportRequest
getExpenseReportRequest);
}

Declaración de entidades de datos y mensajes

Probablemente deseará modelar sus mensajes como clases que definan la carga útil o el cuerpo de cada uno de los mensajes que envíe. Esto se parece a la forma en que se modelan los mensajes mediante herramientas, como WS Contract First (WSCF), al crear servicios Web con ASP.NET.

WCF utiliza de forma predeterminada un motor de serialización denominado DataContractSerializer para serializar y deserializar datos (es decir, para convertirlo a y desde XML). Usamos DataContractSerializer agregando una referencia al espacio de nombres System.Runtime.Serialization y, a continuación, marcamos nuestra clase con el atributo [DataContract] y los miembros que se van a publicar con el atributo [DataMember].

[DataContract]
    public class GetExpenseReportsResponse
    {
        private List<ExpenseReport> reports; 

        [DataMember]
        public List<ExpenseReport> Reports
        {
            get { return reports; }
            set { reports = value; }
        }
    }

Las entidades de datos que se utilizan dentro de los mensajes representan las entidades incluidas dentro del dominio empresarial. Al igual que los contratos de mensajes, podemos usar DataContractSerializer y los atributos para suscribir explícitamente miembros que se están distribuyendo; o, si sólo vamos a modelar datos, podemos usar un enfoque de campos públicos y marcar la clase como serializable.

En la muestra, hemos utilizado el enfoque de contrato de datos para marcar la mensajería. En situaciones reales, a menudo tendrá que tratar con esquemas más complicados, el uso de atributos en los esquemas y los requisitos para utilizar encabezados de SOAP. WCF se encarga de estos casos extremos gracias a la capacidad de definición de clases marcadas con el atributo [MessageContract], que describe todo el sobre de SOAP, en vez de sólo el cuerpo.

Alojamiento del tiempo de ejecución del flujo de trabajo

Los servicios suelen tener en cuenta cualquier comportamiento simultáneo en el que se cree una instancia nueva del tipo de servicio y se mantenga durante el ciclo de vida de una sesión. Para usar el flujo de trabajo en esta situación, debemos crear una instancia de tiempo de ejecución del flujo de trabajo y mantenerla durante el ciclo de vida de la instancia de host de servicios, en vez de hacerlo por llamada.

El enfoque recomendado es utilizar una clase de extensión que se activará tras la creación del host de servicios. Esta extensión creará y mantendrá una instancia global del tiempo de ejecución del flujo de trabajo, permitiendo el acceso por cada una de las instancias de servicio independientes.

Para implementar una extensión en ServiceHost, cree una clase que implemente IExtension<ServiceHostBase.> En la solución, puede encontrar un ejemplo de esto en la clase WfWcfExtension que reside en el proyecto de código WcfExtensions.

Es necesario implementar dos métodos: Attach, que se denominará como la extensión adjunta a su objeto principal y Detach, que se denominará como el objeto principal que se está descargando.

El método Attach, que se muestra aquí, crea una instancia nueva de WorkflowRuntime y la instancia con los servicios necesarios. Almacenaremos esto en un campo privado local denominado workflowRuntime.

void IExtension<ServiceHostBase>.Attach(ServiceHostBase owner)
{
   workflowRuntime = new WorkflowRuntime(workflowServicesConfig);
   ExternalDataExchangeService exSvc = new ExternalDataExchangeService();
   workflowRuntime.AddService(exSvc);
   workflowRuntime.StartRuntime();
}

Como puede ver, nuestra inicialización del tiempo de ejecución del flujo de trabajo implica también la adición de instancias de servicio al tiempo de ejecución, antes de iniciarlo. Al crear sus soluciones, generalmente recomendamos agregar cualquier servicio antes de iniciar el tiempo de ejecución. Sin embargo, si el acoplamiento es una preocupación, podría ser más sensato utilizar un enfoque de enlace en tiempo de ejecución.

En nuestro ejemplo, como parte del método SetUpWorkflowEnvironment de la clase ExpenseService, agregamos una instancia de ExpenseLocalService en ExternalDataExchangeService después de que se haya iniciado WorkflowRuntime.

El método Detach que se muestra aquí desconecta el tiempo de ejecución llamando a StopRuntime.

void IExtension<ServiceHostBase>.Detach(ServiceHostBase owner)
{
   workflowRuntime.StopRuntime();
}

Dado que WorkflowRuntime se crea e inicializa como parte del inicio del host de servicios, cualquier flujo de trabajo existente podrá continuar antes de realizar las llamadas de servicio. Si termina el host de servicios termina, el tiempo de ejecución del flujo de trabajo se desconectará limpiamente.

Nota:

Recomendamos que utilice la persistencia de flujo de trabajo (por ejemplo, SqlWorkflowPersistenceService) al alojar flujos de trabajo y modelar flujos de trabajo de ejecución prolongada, que es la norma habitual. Esto le ofrecerá un mecanismo de persistencia de estado para sobrevivir a cualquier reinicio de la aplicación o de procesos.

Creación de operaciones de servicio

Para crear una clase que contenga el comportamiento de servicio, debe implementar una o más interfaces que definan un contrato de servicio.

public class ExpenseService :
        IExpenseService,
        IExpenseServiceClient,
        IExpenseServiceManager

Para integrar con el flujo de trabajo, nuestros métodos de servicio no contendrán lógica empresarial, sino que en su lugar contendrán código para controlar o desencadenar eventos en un flujo de trabajo en ejecución que encapsule el proceso empresarial.

Para las operaciones que tratan con el flujo de trabajo, iniciaremos un nuevo flujo de trabajo o interactuaremos con un flujo de trabajo ya en ejecución.

La creación de una instancia de flujo de trabajo nueva requiere que utilicemos WorkflowRuntime para crear una instancia nueva del tipo de flujo de trabajo deseado. Ya hemos creado una en nuestra clase de extensión ServiceHost. Para obtener una referencia a esta instancia, debemos encontrar nuestra extensión personalizada con OperationContext.

WfWcfExtension extension =
OperationContext.Current.Host.Extensions.Find<WfWcfExtension>();
workflowRuntime = extension.WorkflowRuntime;

OperationContext es una clase que nos ofrece acceso al contexto de ejecución del método de servicio. Como puede ver en el código anterior, ofrece un valor Singleton denominado Current que nos facilita el contexto del método de servicio actual. Llamamos a la propiedad Host para capturar de nuevo una instancia en el ServiceHost que se está ejecutando y, a continuación, encontramos nuestra extensión en función de su tipo.

Después de que tengamos una referencia a nuestra instancia de extensión, podemos volver a WorkflowRuntime a través de nuestra propiedad pública y utilizarla para crear una instancia nueva de nuestro SequentialWorkflow.

Guid workflowInstanceId =
submitExpenseReportRequest.Report.ExpenseReportId; 

Assembly asm = Assembly.Load("ExpenseWorkflows");
Type workflowType = asm.GetType("ExpenseWorkflows.SequentialWorkflow"); 

WorkflowInstance workflowInstance =
   workflowRuntime.CreateWorkflow(workflowType, null, workflowInstanceId);
workflowInstance.Start(); 

expenseLocalService.RaiseExpenseReportSubmittedEvent(
   workflowInstanceId, submitExpenseReportRequest.Report);

En el código anterior, creamos una instancia de flujo de trabajo nueva basada en un tipo predefinido. Si bien esto se podía lograr a través de la instancia de tipo directo, esto demuestra que en realidad podríamos tener flexibilidad para crear un flujo de trabajo basado en una regla dinámica en el tiempo de ejecución, en vez de hacerlo a través de un enlace con tipos más sólidos.

La última línea señala el inicio del flujo de trabajo mediante el desencadenamiento de un evento manejado por el primer HandleExternalEventActivity del flujo de trabajo. Esto se desencadena a través de una instancia de la clase ExpenseLocalService. En la muestra, ExpenseLocalService se utiliza para interactuar con el flujo de trabajo a través del inicio de nuevos flujos de trabajo o el desencadenamiento de eventos en flujos de trabajo existentes. Utilizamos esta clase como mecanismo de encapsulación de nuestro proceso empresarial. Internamente, esto se implementa con WF.

Figura 3. Nuestro flujo de trabajo se inicia con HandleExternalEventActivity.

El otro tipo de situación con la que trataremos es llamar de nuevo a un flujo de trabajo existente y desencadenar eventos. Debemos desencadenar un evento en el motor de flujo de trabajo que provoque que nuestro flujo de trabajo existente reciba el evento y continúe el procesamiento.

Un ejemplo de dónde se producirá esto dentro del flujo de informes de gastos se produce cuando se necesita al Director de aprobación. El flujo de trabajo llama al método externo para RequestManagerApproval que desencadenará una alerta para el director acerca de que deben aprobar o rechazar un nuevo informe de gastos.

El flujo de trabajo contiene ListenActivity, que se bloqueará hasta que se haya producido uno de los eventos posibles. En este caso, recibimos un evento que indica que un director ha revisado el informe o que ha transcurrido nuestro tiempo de espera en función de DelayActivity.

Figura 4. Flujo de actividad personalizado de ManagerApproval

Guid workflowInstanceId =
submitReviewedExpenseReportRequest.Report.ExpenseReportId; 

ExpenseReportReviewedEventArgs e =
   new ExpenseReportReviewedEventArgs(workflowInstanceId, report, review); 

if (ExpenseReportReviewed != null)
{
   ExpenseReportReviewed(null, e);
}

Cuando un director revisa un informe con ManagerApplication, se vuelve a realizar una llamada de servicio al host solicitando el método SubmitReviewedExpenseReport que desencadena el evento ExpenseReportReviewed.

Al desencadenar un evento HandleExternalEventActivity en el flujo de trabajo, debe conocer el GUID de la instancia del flujo de trabajo con que tratamos, para que el evento se pueda dirigir.

Cada evento se desencadena con EventArgs, que permite volver a transferir datos al flujo de trabajo a través del modelo de eventos. En este caso, podemos transferir detalles del estado actual del informe y los datos que nos dan contexto acerca de la actividad de revisión.

En el flujo de trabajo, los eventos se transmiten automáticamente al flujo de trabajo a través de las propiedades en HandleExternalEventActivity.

Figura 5. Estamos transmitiendo HandleExternalEventActivity a la interfaz de IExpenseLocalService.

Especifique el tipo de interfaz que se debe marcar con el atributo [ExternalDataExchange] y, a continuación, el evento de esa interfaz al que se va a suscribir HandleExternalEventActivity.

Los argumentos del evento se deben derivar desde la clase ExternalDataEventArgs. Como mínimo, esto significa que cada evento contendrá el contexto, al igual que el valor InstanceId del flujo de trabajo. El tiempo de ejecución del flujo de trabajo administra el enrutamiento del evento a la instancia de flujo de trabajo correcta con el fin de continuarlo. Si utilizamos un servicio de persistencia, el tiempo de ejecución también administrará la hidratación y la rehidratación de cualquier estado de ejecución del flujo de trabajo durante el transcurso de su ejecución.

Alojamiento del servicio

Para alojar un servicio de WCF, debemos ejecutarlo dentro del contenedor ServiceHost.

Para revisar cómo se puede lograr el alojamiento con WCF, permítanos recordar las alternativas que tenemos disponibles:

Generalmente, si está creando servicios web, le conviene elegir el alojamiento mediante Internet Information Services. Si está creando un extremo de instancia única que funcione como demonio, generalmente le conviene elegir el alojamiento a través de un servicio de Windows.

En nuestro ejemplo, estamos alojando la instancia de servicio principal dentro de una aplicación de consola de Windows de forma parecida a cómo se alojaría un servicio de Windows.

Para implementar un servicio, debemos crear una instancia de la clase ServiceHost y abrir sus extremos para cada tipo de servicio que queramos publicar. ServiceHost toma varios argumentos como parte de su constructor; sin embargo, el argumento principal es un argumento Type o una instancia de una clase que implementa ServiceContract.

Después de haber establecido un host, analizará sintácticamente cualquier configuración disponible y la fusionará con cualquier configuración agregada explícitamente, con el fin de determinar los extremos disponibles y abrirlos para publicar. A medida que se reciben llamadas de clientes, las solicitudes se procesan en nuevos subprocesos de trabajo en segundo plano y se dirigen a las operaciones de servicio apropiadas, según les indica el nombre de contrato de SOAP y la acción del mensaje.

using (ServiceHost serviceHost = new ServiceHost(new ExpenseService()))
{
   WfWcfExtension wfWcfExtension =
      new WfWcfExtension("WorkflowRuntimeConfig");
   serviceHost.Extensions.Add(wfWcfExtension);
   serviceHost.Open(); 

   // block the process at this point, for example Console.ReadLine(); 

   serviceHost.Close();
}

Al configurar ServiceHost, debe hacerlo así antes de abrir los extremos para las conexiones. Puede hacerlo así, como le hemos mostrado anteriormente, interactuando con el objeto de host antes de llamar a .Open(). Es recomendable que utilice un ámbito de uso para que ServiceHost esté dispuesto antes del uso y que llame explícitamente a Close() al final de ese ámbito para desconectar limpiamente cualquier extremo o conexión activos.

Configuración de implementación

WCF ofrece un mecanismo para separar las preocupaciones de implementación de la implementación en sí mediante la configuración de los extremos a través de la configuración XML. Esto ofrece a los administradores la capacidad de modificar la directiva de un servicio sin tener que perfeccionar el código.

Cada servicio se publica en uno o más extremos. Un extremo es simplemente un punto de conexión dirigible en el que los clientes pueden consumir el servicio. En WCF, cada extremo se declara con tres atributos que se han popularizado como los ABC de WCF.

Son Address, Binding y Contract.

Address: La ubicación dirigible única de este extremo. Generalmente, será un URI que le proporciona la dirección absoluta en la que el servicio está escuchando solicitudes; por ejemplo: http://myhost/myservice o net.tcp://myhost:400/myservice

Binding: La directiva que dicta el protocolo para la comunicación entre el servicio y sus consumidores. Binding especifica aspectos tales como el tipo del transporte que se está utilizando, la forma en que se están codificando los mensajes y la forma en que se serializan los datos. WCF incluye varios valores Binding “de fábrica” que admiten la mayoría de las situaciones comunes.

Contract: Las operaciones y los datos que se van a publicar según hayamos definido a través de una interfaz en el código.

Para configurar nuestro servicio, debemos declarar una configuración que declare nuestro servicio y configurar cualquier número de extremos para el servicio. Dado que un servicio podría implementar cualquier número de contratos, esto afectará también al número de extremos que tenga que publicar.

A continuación le mostramos una configuración de ejemplo.

<services>
   <service name="ExpenseServices.ExpenseService">
      <endpoint
         address="http://localhost:8081/ExpenseService/Manager"
         binding="wsHttpBinding"
         contract="ExpenseContracts.IExpenseServiceManager" />
<endpoint
         address="http://localhost:8081/ExpenseService/Client"
         binding="wsDualHttpBinding"
         contract="ExpenseContracts.IExpenseServiceClient" />
   </service>
</services>

En este ejemplo de configuración, declaramos una configuración para el servicio de tipo ExpenseServices ExpenseService. Esto permite que el tiempo de ejecución encuentre la configuración cuando creamos una instancia de un nuevo ServiceHost basado en este tipo.

Consumo de servicios

El consumo de servicios a través de WCF se realiza con la clase ChannelFactory.ChannelFactory utiliza el patrón de fábrica para ofrecernos instancias proxy de un contrato de servicio que se conecta con el extremo especificado en la configuración. Podemos configurar la fábrica con información de tiempo de ejecución, como credenciales de seguridad y certificados para cifrado de mensajes, o para determinar la información del extremo dinámicamente.

private IExpenseServiceManager CreateChannelExpenseServiceManager()
{
   ChannelFactory<IExpenseServiceManager> factory = new
ChannelFactory<IExpenseServiceManager>("ExpenseServiceManager");
   IExpenseServiceManager proxy = factory.CreateChannel(); 

   return proxy;
}

Como puede ver, inicialmente creamos una instancia de la fábrica, que utiliza un argumento genérico para que el contrato de servicio nos permita construir una fábrica más precisa que devolverá sólo instancias del contrato deseado. También especificamos un argumento que determine la configuración que se utilizará para el extremo. En este caso, estamos utilizando una configuración de extremo denominada ExpenseServiceManager, que se refiere a la configuración que tenemos en nuestro archivo de configuración de la aplicación.

<system.serviceModel>
   <client>
         <endpoint name="ExpenseServiceManager"
            address="http://localhost:8081/ExpenseService/Manager"
            binding="wsHttpBinding"
            contract="ExpenseContracts.IExpenseServiceManager" />
   </client>
</system.serviceModel>

Puede comprobar que la definición del extremo coincide exactamente con la definición que se declara en la configuración del host. Generalmente, la única vez que tendrá una configuración diferente será cuando la dirección del cliente sea diferente a la del servidor debido a que se está implementando una configuración de red o un comportamiento personalizado.

Si ha instalado Windows SDK, podrá disponer de una herramienta (svcutil) con el fin de automatizar la creación de una configuración de extremos y clases proxy, que podrá integrar en su solución. El servicio de destino debe publicar una descripción de sus metadatos a través de WSDL o WS-Metadataexchange para poder utilizar esta herramienta

Configuración de canales dúplex

Hasta ahora, hemos supuesto que nuestro flujo de comunicación utilizará un patrón de colaboración de solicitud y respuesta, donde los mensajes los envía un consumidor y los responde un servicio. WCF admite varios flujos de mensajes alternativos, como la comunicación dúplex de un solo sentido (”Fire and Forget”) o bidireccional. Si tratamos con un flujo de mensajes en el que cualquier parte puede iniciar una conversación, tendremos que utilizar un dúplex o un canal bidireccional. Los canales dúplex pueden resultar muy efectivos para sistemas conectados de forma más sólida en los que se puedan enviar datos desde cualquier dirección. Un ejemplo de dónde le podría resultar esto útil es a la hora proporcionar devoluciones de llamada desde eventos.

Implementación de devoluciones de llamada de clientes

Las devoluciones de llamada de clientes se implementan en WCF a través de un concepto denominado CallbackContracts. Para el contrato que publiquemos, podemos nombrar un segundo contrato para definir las operaciones que los clientes publicarán y cuyas llamadas se puedan devolver a través de la ejecución de código en el servicio.

Para declarar CallbackContract, especifique el tipo de interfaz como parte del contrato de servicio desde el que se estará devolviendo la llamada.

[ServiceContract(CallbackContract =
typeof(IExpenseServiceClientCallback))]

También es necesario usar un enlace que admita canales dúplex, como netTcpBinding o wsDualHttpBinding. El dúplex sobre TCP se logra mediante una conexión bidireccional que se establece y mantiene en todo el intercambio de mensajes. Sobre HTTP, esto se logra mediante una devolución de llamada a una escucha de cliente. Dado que puede que el cliente no sea consciente de su ruta de regreso o que desee definir esto de forma más sólida a través de una configuración, podemos utilizar una configuración de enlace personalizada para declarar una dirección clientBaseAddress alternativa.

<endpoint binding="wsDualHttpBinding"
bindingConfiguration="AlternativeClientCallback"/>
<bindings>
   <wsDualHttpBinding>
      <binding name="AlternativeClientCallback"
clientBaseAddress="http://localhost:8082/ExpenseService/ClientCallback"/>
   </wsDualHttpBinding>
</bindings>

Implementación de devoluciones de llamada en el cliente

Implementar un contrato de devolución de llamada es exactamente lo mismo que implementar un contrato de servicio. Debemos proporcionar una implementación de la interfaz que hemos definido.

class CallbackHandler : IExpenseServiceClientCallback
{
   public void ExpenseReportReviewed(
ExpenseReportReviewedRequest expenseReportReviewedRequest)
        {
            // We implement client logic to respond to the callback here.
        }
}

Para permitir que el host tenga una instancia de nuestra clase CallbackHandler en la que devolver la llamada, debemos configurar nuestro canal de cliente de tal manera que sea consciente de la naturaleza dúplex de la conexión.

Antes de nada, como hemos descrito anteriormente, utilizaremos un enlace que admita canales dúplex. En segundo lugar, cuando inicialicemos nuestra conexión con el extremo de servicio, utilizaremos una versión subclasificada de ChannelFactory, denominada DuplexChannelFactory, que creará automáticamente una conexión dúplex para el servicio.

private IExpenseServiceClient CreateChannelExpenseServiceClient()
{
   InstanceContext context = new InstanceContext(new CallbackHandler()); 

   DuplexChannelFactory<IExpenseServiceClient> factory =
new DuplexChannelFactory<IExpenseServiceClient>(context,
"ExpenseServiceClient");
   IExpenseServiceClient proxy = factory.CreateChannel(); 

   return proxy;
}

La diferencia clave al usar DuplexChannelFactory es que inicializamos una instancia de nuestra clase CallbackHandler y la transferimos al constructor para que la fábrica inicialice un contexto que se utilice en las devoluciones de llamada.

Implementación de devoluciones de llamada desde el host

Desde la perspectiva del host, podemos obtener una referencia para devolver la llamada a nuestro cliente a través del canal de devolución de llamada que se define en nuestro contrato IExpenseServiceClient.

[ServiceContract(CallbackContract =
typeof(IExpenseServiceClientCallback))]
public interface IExpenseServiceClient : IExpenseService

El atributo CallbackContract declara la interfaz que define el contrato para las devoluciones de llamada realizadas desde el host.

Para realizar la devolución de llamada, obtenemos una referencia al contrato de devolución de llamada llamando a OperationContext.Current.GetCallbackChannel, como se muestra aquí.

IExpenseServiceClientCallback callback =
                   OperationContext.Current.GetCallbackChannel
<IExpenseServiceClientCallback>();
callback.ExpenseReportReviewed(new
ExpenseReportReviewedRequest(e.Report));

Después de que tengamos una referencia a nuestro canal de devolución de llamada, podemos llamarlo con normalidad.

A continuación nuestro amigo Jeremy Boyd nos da algunas instrucciones que debemos recordar al diseñar los servicios:

Fuente: http://www.microsoft.com/spanish/msdn/articulos/

Publicado por: Jeremy Boyd, consultor experto técnico de Intergen, proveedor de soluciones de Nueva Zelanda y Partner Gold Certified de Microsoft, así como Director regional de MSDN en la comunidad de Nueva Zelanda.

La forma más fácil y productiva de desarrollar software para la plataforma Microsoft .NET® es sin duda con ayuda de Visual Studio .NET®. En realidad, recomiendo que los interesados se suscriban a “MSDN Professional”. Es un poco más cara que Visual Studio únicamente, pero incluye mucho software adicional, como todos los sistemas operativos de Microsoft, SDKs, DDKs y una “base de conocimiento”, además de un año de actualizaciones.A pesar de todas las ventajas que presenta Visual Studio, es posible desarrollar para la plataforma .NET sin él. Para ello, debe obtener el “SDK de .NET Framework”, que puede descargar de http://msdn.microsoft.com/downloads/default.asp. El tamaño total es de más de 130 MB y está disponible tanto en un único archivo como en varios archivos separados.

Observe que NO se trata del runtime de .NET Framework. El runtime se conoce como “.NET Framework redistribuible”, tiene aproximadamente 20 MB y estará disponible en breve en otros idiomas además del inglés.

El SDK incluye el runtime, varias herramientas de desarrollo y documentación. Permite la creación de cualquier tipo de aplicación: consola, DLLs, Windows, ASP.NET y servicios de Web. Está claro que tendremos que programar como se hacía hace muchos años, creando los programas en un editor de textos como Notepad y utilizando herramientas de línea de comandos.

Veamos cómo crear algunos tipos de aplicaciones utilizando el lenguaje C# y el “SDK de .NET Framework”. Partimos del principio de que usted ha descargado e instalado el SDK. Los ejemplos de este artículo fueron probados en una instalación nueva de Windows XP, agregando únicamente las actualizaciones indicadas en el sitio “Windows Update” y en el SDK de Framework.

Aplicación en modo de consola.

Se trata del tipo más fácil de desarrollar. Escriba el programa siguiente en Notepad y guárdelo con el nombre “HolaConsola.cs”:

using System; 

class Hola {
  public static void Main() {
    Console.WriteLine("Hola mundo, desde la consola");
  }
}

El programa “CSC.EXE” es el compilador de línea de comandos de C#. Toma uno o varios archivos “cs” y los compila para crear archivos .EXE o .DLL.

Aplicaciones de Web.

Podemos crear aplicaciones de ASP.NET de una forma muy parecida al ASP tradicional, donde sólo teníamos un archivo que combinaba el código HTML con código del lenguaje de programación.

Para crear una aplicación de Web de esta forma, basta con crear archivos “aspx” en el directorio del servidor de Web, normalmente c:\Inetpub\wwwroot. Como ejemplo, cree un archivo con el nombre “HolaSencillo.aspx” .

Hola desde una página ASP.NET sencilla

rn”);
Response.Write(”Hola mundo!”);
Response.Write(”rn”);
}
%>Observe lo siguiente:

• La primera línea indica el lenguaje utilizado.
• Al igual que en el ASP tradicional, el código puede ser situado entre “”.
• Estamos usando el lenguaje C#, lo que permite una programación mucho más avanzada que con el ASP tradicional. Podríamos usar cualquier lenguaje disponible para la plataforma .NET.
• El programa se compilará automáticamente cuando se llame a la página por primera vez.

Puede probar el proyecto anterior abriendo el navegador y navegando hasta el URL “http://localhost/HolaSencillo.aspx”:

Al programar de esta forma, usted pierde las facilidades que ofrece una herramienta de tipo RAD, pero puede beneficiarse de algunas ventajas exclusivas de la plataforma .NET, como los controles que se ejecutan en el servidor. Los controles que se ejecutan en el servidor suponen varias ventajas:

• Procesan las entradas del navegador: no es necesario usar la propiedad Request.
• Generan una salida a partir de sus propiedades: podemos generar una salida con sólo alterar las propiedades y haciendo llamadas a métodos, sin usar el objeto Response.
• Conservan su estado cuando la página recibe un PostBack (cuando la página se llama a sí misma).

Veamos como ejemplo una calculadora que usa controles del servidor, creada en el archivo CalcComps.aspx:

0 

0


private void Button1_Click(object sender, System.EventArgs e)
{
  double N1 = Convert.ToDouble(TextBox1.Text);
  double N2 = Convert.ToDouble(TextBox2.Text);
  double R = N1 + N2;
  ListBox1.Items.Add(R.ToString());
} 

override protected void OnInit(EventArgs e) {
  Button1.Click += new System.EventHandler(Button1_Click);
  base.OnInit(e);
}

Veamos el resultado del programa:

Observe lo siguiente:

• La página contiene varios componentes con el atributo “runat=server”. Esto significa que se creará en el servidor una instancia del componente correspondiente, cada vez que se llame a la página.
• Los componentes procesan la entrada, generan la salida y conservan su estado. Observe que los componentes TextBox y ListBox conservan sus contenidos sin que tengamos que hacer nada.
• El código se encuentra dentro de un bloque SCRIPT.
• La llamada al método OnInit se realiza con la carga inicial de la página. En él, se asocia el evento Click del botón al código que procesará el evento.
• Los valores de los campos se obtienen en las propiedades de los componentes, en lugar del objeto Request.
• La salida se genera indirectamente. En primer lugar alteramos las propiedades de los componentes, que a su vez crean una página HTML, acorde con el navegador utilizado remotamente.

WebServices.

Para desarrollar un servicio de Web sin Visual Studio .NET, sólo es necesario crear un archivo con la extensión “asmx” en el directorio del servidor de Web, normalmente c:\Inetpub\wwwroot. Cree un archivo con el nombre “MiServicio.asmx” y escriba el código siguiente:

using System.Web.Services; 

[WebService(Namespace="http://picaplan.com.br/webservices/")]
public class Cuentas: System.Web.Services.WebService {
  [WebMethod]
  public double Suma(double A, double B) {
    return A + B;
  }
  [WebMethod]
  public double Producto(double A, double B) {
    return A * B;
  }
}

Puede llamar al servicio de Web desde un navegador de Web. En este caso, se crea automáticamente una página de prueba.

También se crea automáticamente una página con la descripción del servicio, con el estándar WDSL.

Observe lo siguiente:

• La primera línea indica que la página es un servicio de Web y que el lenguaje utilizado es C#.
• La clase Cuentas contendrá los métodos a los que se llamará de forma remota.
• La clase Cuentas se deriva de System.Web.Services.WebService. Esto no es imprescindible, pero resulta útil si necesita tener acceso a las variables de sesión, los encabezados de HTTP y otras características del protocolo SOAP.
• El atributo “Namespace” no es absolutamente imprescindible para que funcione el servicio de Web, pero la norma incluye el requisito de asignar un nombre exclusivo al servicio de Web, basado normalmente en un URL al que usted tenga acceso.
• El atributo “WebMethod” es imprescindible e indica que es posible llamar al método a través de SOAP.
• Los tipos entregados y devueltos por los métodos deben ser “serializables”. Los tipos numéricos, string, struct y arrays son serializables. Hay otras clases de la biblioteca, por ejemplo DataSet, que también son serializables.

Llamadas a servicios de Web.

La forma más fácil de llamar a un servicio de Web es crear una clase Proxy que funciona exactamente como una clase de .NET, pero que es capaz de llamar al servicio de Web. Esto puede hacerse con la utilidad WSDL.EXE. El comando que permite generar una clase capaz de llamar al servicio de Web anterior sería el siguiente:

C:>wsdl http://localhost/MiServicio.asmx

Este comando crea un archivo con el mismo nombre que la clase que implementa el servicio de Web, “Cuentas.cs” en nuestro caso.

Llamaremos al servicio de Web de la aplicación siguiente en modo de consola, en el archivo “LlamarCuentas.cs”:

using System; 

class Hola {
  public static void Main() {
    Cuentas C = new Cuentas();
    double R = C.Suma(10, 30);
    Console.WriteLine(R);
  }
}

La aplicación anterior debe ser compilada con el comando siguiente, para unir los dos archivos fuente en el mismo ejecutable y generar el ejecutable LlamarCuentas.EXE:

C:>csc LlamarCuentas.cs Cuentas.cs

Fuente:

http://www.microsoft.com/spanish/msdn/comunidad/mtj.net/voices/art58.asp 

Escrito por Mauro Sant'Anna (mas_mauro@hotmail.com). Mauro es Director regional de MSDN,

consultor e instructor de MAS Informática (www.mas.com.br).

Guao!!!!

La tecnología aumenta cada vez más rápido y así mismo lo que las hace funcionar, tal es el caso de algo no tan nuevo pero que últimamente a dado que hablar tiene que ver con el .Net Framework y mas específicamente sobre WCF:

Windows Communication Foundation (WCF) es la plataforma de última generación de Microsoft diseñada para la creación de sistemas distribuidos. Se lanzó al mercado como parte de .NET Framework 3.0 con la idea de consolidar y ampliar las API de versiones anteriores de Framework (por ejemplo, los servicios web ASP.NET, .NET Remoting, Enterprise Services (COM+) y Message Queuing).

Si bien empezar a usar WCF no es difícil, sí hay un par de pasos durante el proceso que quizás no sean del todo claros. En este artículo le guiará a través del proceso de creación y consumo de dos sencillos servicios. Para conseguir nuestro objetivo, abordaremos aspectos como las clases de servicio, los hosts de servicios, la configuración de servicios y los proxy de cliente.

Lo siguiente que recomendamos es tener instalados Visual Studio 2005,.NET .NET Framework 3.0y las extensiones de Visual Studio 2005 para .NET Framework 3.0 (WCF y WPF).

Para empezar, se creo una solución vacía denominada GettingStartedWithWCF..

Clases de servicio

La clase de servicio implementa la funcionalidad que exponen las operaciones del servicio. Se trata de una clase .NET normal sin restricciones de herencia. Para habilitar una clase como clase del servicio, se aplican los atributos ServiceContract y OperationContract del espacio de nombres System.ServiceModel. Estos atributos pueden incluirse en la misma declaración de clase o simplemente en la declaración de una interfaz implementada por la clase. El uso de estos atributos no significa que la clase sea un servicio. Significa simplemente que la clase puede estar expuesta igual que un servicio.

Agregaremos un proyecto de biblioteca de clases para las clases de servicio. Para ello, haga clic con el botón secundario en la solución, seleccione Agregar | Nuevo proyecto y, a continuación, cree un proyecto de biblioteca de clases denominado ServiceLib..

Cambie el nombre del archivo Class1.vb por MathService.vb.. El nombre de la clase debería cambiarse automáticamente por MathService. Si no es así, lleve a cabo el cambio manualmente.

Agregue una referencia a System.ServiceModel.. Acabará usando este proyecto de manera habitual, ya que este ensamblado constituye la base de WCF.

Agregue dos métodos a la clase MathService: uno que agregue dos enteros (denominado Add) y uno que permita obtener el cuadrado de un doble (denominado Square).). Agregue una instrucción Imports al espacio de nombres System.ServiceModel y, a continuación, incluya en esta clase el atributo ServiceContract y en los métodos el atributo OperationContract.

Imports System.ServiceModel

<ServiceContract()> _
PublicClass MathService

<OperationContract()> _
PublicFunctionAdd(ByVal x AsInteger, ByVal y AsInteger) _
AsInteger
Return x + y
EndFunction

<OperationContract()> _
PublicFunction Square(ByVal x AsDouble) AsDouble
Return x * x
EndFunction

EndClass

Como se ha mencionado anteriormente, estos atributos también pueden aplicarse a una interfaz. Para verlo, agregue una clase nueva al proyecto ServiceLib denominada HelloService y agregue el código que se muestra a continuación.

Imports System.ServiceModel

<ServiceContract()> _
PublicInterface IHello

<OperationContract()> _
Function SayHello(ByVal name AsString) AsString

EndInterface

PublicClass HelloService
Implements IHello

PublicFunction SayHello(ByVal name AsString) _
AsStringImplements IHello.SayHello

Return“Hello “ + name
EndFunction

EndClass

Hosts de servicios

Para que la funcionalidad contenida en la clase del servicio esté a disposición de las aplicaciones cliente, se necesita un host de servicio. Se trata de una aplicación que escuchará las solicitudes de los clientes y creará instancias de la clase del servicio con el fin de procesar estas solicitudes. Con WCF, es posible usar IIS como host, pero también puede crearse una aplicación personalizada.

En este caso crearemos ambas clases de hosts, empezando por el hospedaje web. Haga clic con el botón secundario en la solución para agregar un sitio web. A continuación, seleccione Agregar | Nuevo sitio Web y elija la plantilla de servicio de WCF. Asegúrese de establecer la ubicación en una ruta de acceso del sistema de archivos en una carpeta del archivo de la solución.

Veamos rápidamente el código del texto reutilizable de Service.vb. La plantilla asume que vamos a codificar la funcionalidad para el servicio aquí, de modo que dispone de una interfaz y una clase de servicio de muestra con los atributos adecuados (además de un atributo DataContract,un tema que no entraremos a debatir en este artículo). Ya hemos creado las clases de servicio en el proyecto de ServiceLib y, por lo tanto, ahora podemos eliminar el archivo Servicio.vb.

Abra Service.svc y consulte los valores de los atributos. Los servicios de hospedaje web usan el mismo modelo que las antiguas tecnologías ASP.NET. Vinculan el archivo al que se pretende llegar con el archivo que contiene el código. Ésta es la misma técnica de código subyacente que se usa en ASP.NET. Dado que ya tenemos una clase de servicio compilada, podemos quitar este atributo y, a continuación, poner el nombre completo del tipo MathService como el valor para el atributo Service.

<% @ServiceHost Language=VB Service=”ServiceLib.MathService” %>

Finalmente, agregue una referencia al proyecto ServiceLib.

Ahora cree la solución. Una vez creada, el explorador de soluciones deberá parecerse al que se muestra a continuación.

Esto es todo en cuanto al servicio de hospedaje web. Ahora seguiremos con el uso de aplicaciones personalizadas como hosts. Para ello, se puede usar una aplicación de Windows Forms, una aplicación de consola o bien un servicio de Windows. En este caso usaremos una aplicación de consola.

Haga clic con el botón secundario en la solución y elija Agregar | Nuevo proyecto. Cree una aplicación de consola denominada ConsoleServiceHost..

Dado que necesitaremos crear referencias a System.ServiceModel (para la clase que realizará el hospedaje) y ServiceLib. (para la clase de servicio), primero agregue estas referencias.

Hacer que una aplicación .NET hospede un servicio es algo muy sencillo. Cree simplemente una instancia de tipo ServiceHost, asígnele el Type correspondiente a la clase de servicio que va a hospedar y, a continuación, llame el método Open. Este método Open hace que el host comience a escuchar las solicitudes. Como estamos usando una aplicación de consola, agregaremos una llamada a ReadLine para que la aplicación siga ejecutándose una vez abierto el host. También crearemos el host mediante una instrucción Using para asegurarnos de que se cierra y se elimina correctamente al cerrarse la aplicación de consola. Antes usamos MathService, así que ahora, para este proyecto, usaremos HelloService.

Imports System.ServiceModel

Module Module1

Sub Main()
Dim t As Type = GetType(ServiceLib.HelloService)
Using host AsNew ServiceHost(t)
host.Open()

Console.WriteLine(“Service started…”)
Console.ReadLine()
End Using
EndSub

EndModule

Configuración del servicio

Es posible que haya observado que, al configurar los hosts, no indicamos la manera en la que el cliente debe comunicarse con el servicio. Pues bien, esto se consigue mediante la configuración del servicio. Y aunque la configuración puede especificarse por medio de código, lo más habitual será hacerlo mediante XML en un archivo .config.

Para que un cliente pueda comunicarse con un servicio, se necesita un extremo. Un extremo está formado por tres componentes: una dirección, un enlace y un contrato. Éstos son los componentes fundamentales de WCF. La dirección es el URI que identifica dónde puede encontrarse el servicio. El enlace se usa para definir las reglas de la comunicación (por ejemplo, la codificación, si los mensajes necesitan ser protegidos, la manera en la que el servicio autenticará al cliente, etc.). Finalmente, el contrato define las operaciones expuestas por el servicio. Se trata básicamente de una referencia a la clase de servicio.

WCF dispone de varios enlaces integrados configurados para usos empresariales habituales (consulte la tabla que hay a continuación). Es posible personalizar estos enlaces mediante su configuración, aunque también es posible crear enlaces personalizados propios para adaptarlos a las necesidades del sistema. Para no complicar demasiado el proceso, usaremos el enlace básico HTTP, que sigue el protocolo SOAP 1.1.

Ahora necesitaremos configurar los hosts. Empezaremos con la aplicación de consola. En primer lugar necesitamos un sitio para colocar la información de configuración, de modo que agregaremos un archivo app.config. Haga clic con el botón secundario en el proyecto y elija Agregar | Nuevo elemento. A continuación, cree un archivo de configuración de la aplicación usando el nombre predeterminado (app.config).

Para configurar el extremo, se necesita una dirección, un enlace y un contrato. Veamos estos componentes en su orden inverso. El contrato ya quedó determinado a través del tipo de contrato que proporcionamos al constructor