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®.

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.

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!

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

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/

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.

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).

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 ServiceHost Para nuestra aplicación, será ServiceLib.IHello.. El enlace será basicHttpBinding, tal como ya mencionamos antes. Para la dirección usaremos “http://localhost:8081/HelloService”,lo que significa que los clientes deberán enviar los mensajes a través del protocolo HTTP al puerto 8081 del servidor local usando HelloService como el nombre de aplicación.

Para usar el asistente para la creación del proxy que se describe en la sección siguiente, debemos realizar un paso adicional. A diferencia de los servicios web ASP.NET, los servicios WCF no exponen una descripción del servicio (ni los metadatos) de forma automática. Por lo tanto, para habilitar esta característica, necesitamos agregar un comportamiento del servicio e indicarle a éste que use este comportamiento nuevo.

Reemplace todo el contenido del archivo app.config con el documento XML que se muestra a continuación para así configurar el host de consola.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior name="mexEnabled">
<serviceMetadata
httpGetEnabled="true"
httpGetUrl="http://localhost:8081/HelloService" />
</behavior>
</serviceBehaviors>
</behaviors>
<services>
<service
behaviorConfiguration="mexEnabled"
name="ServiceLib.HelloService">
<endpoint
address="http://localhost:8081/HelloService"
binding="basicHttpBinding"
contract="ServiceLib.IHello" />
</service>
</services>
</system.serviceModel>
</configuration>

La configuración del host web es prácticamente igual. Las diferencias son que la configuración XML se realiza en el archivo web.config, que no es necesario indicar una dirección para el extremo (ésta se determinará a través de la dirección del archivo Service.svc del servidor web) y que el contrato que el host web expone es MathService, no HelloService.

Reemplace todo el contenido del archivo web.config con el documento XML que se muestra a continuación para así configurar el host de consola.

<?xml version="1.0"?>
<configuration>
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior name="mexEnabled">
<serviceMetadata
httpGetEnabled="true" />
</behavior>
</serviceBehaviors>
</behaviors>
<services>
<service
behaviorConfiguration="mexEnabled"
name="ServiceLib.MathService">
<endpoint
address=""
binding="basicHttpBinding"
contract="ServiceLib.MathService" />
</service>
</services>
</system.serviceModel>
</configuration>

Configuración del cliente y proxy

Ya estamos preparados para crear la aplicación cliente. Haga clic con el botón secundario en la solución, elija Agregar | Nuevo proyecto, y cree una aplicación de Windows denominada ServiceClient..

Para poder consumir los servicios, es necesario que configuremos antes el cliente y los proxy. Esta configuración es casi igual que la del servidor, ya que se requiere que un extremo sea compatible con los hosts del servicio. Los proxy son las clases del proyecto del cliente que se usan para representar los servicios; de esta manera permiten llamar las operaciones del servicio mediante una forma de tipos inflexible.

Afortunadamente, las extensiones de Visual Studio para .NET 3.0 incluyen un asistente que creará la configuración y los proxy necesarios mediante los metadatos del servicio. Lo único que se necesita es la dirección URL correcta del host del servicio.

Empecemos por el servicio de hospedaje web. Dado que elegimos un sitio web basado en archivos, necesitamos saber el número de puerto que usa Visual Studio. Éste puede averiguarse mediante la ventana de propiedades. Haga clic en el proyecto del sitio web y busque el número de puerto. En la aplicación de muestra, el número de puerto es el 13419.

Al agregar el nombre del proyecto web (WebServiceHost) y el nombre del archivo svc (Servicio.svc), obtenemos la dirección URL http://localhost:13419/WebServiceHost/Service.svc.

Para configurar el cliente para poder usar este servicio y crear la clase de proxy, haga clic con el botón secundario en el proyecto ServiceClient y elija la opción para agregar una referencia de servicio. Escriba la dirección URL del servicio para el Servicio URI y MathProxy para el nombre de la referencia del servicio y, a continuación, haga clic en Aceptar.

Verá como la aplicación cliente ahora tiene un archivo app.config además de un archivo MathProxy.map en la carpeta denominada Service References. Hablaremos de estos aspectos con más detalle tras haber agregado una referencia al servicio hospedado en la consola.

Para el servicio hospedado en la consola, la dirección URL necesaria para tener acceso a los metadatos del servicio está almacenada en el archivo app.config. Si observa el atributo httpGetUrl del elemento serviceMetadata, verá que se configuró para http://localhost:8081/HelloService.

Antes de actualizar el cliente mediante el asistente para agregar referencias de servicio, debemos iniciar el host. Haga clic con el botón secundario en el proyecto ConsoleServiceHost y elija Depurar | Iniciar nueva instancia.

Cuando se esté ejecutando el host, haga clic con el botón secundario en el proyecto ServiceClient, elija la opción para agregar una referencia de servicio y escriba el URI adecuado en el campo del URI del servicio y HelloProxy para el nombre de la referencia del servicio.

Una vez agregada la referencia, asegúrese de detener el host de la consola. Deberá comprobar que HelloProxy.map se haya agregado a la carpeta Service References del proyecto del cliente.

Al abrir el archivo app.config en el proyecto ServiceClient, verá el archivo XML que se generó con el asistente. Parece complejo, pero no lo es. Para facilitar los ajustes de la configuración, el asistente coloca diversos atributos en el archivo junto con los valores predeterminados de configuración. Dado que no es necesario incluir los atributos con los valores predeterminados en la configuración, se puede simplificar el documento XML como el que se muestra a continuación.

La configuración contiene un elemento extremo para cada host, y los atributos de la dirección y del enlace de estos elementos coinciden con los valores de los hosts. Lo que sí es diferente es el contrato. Esto se debe a que el cliente no establece referencias con la clase original del servicio, sino que, en lugar de eso, establece referencias con un proxy del cliente generado por el asistente a partir de los metadatos del servicio.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<client>
<endpoint address="http://localhost:13419/WebServiceHost/Service.svc"
binding="basicHttpBinding"
contract="MathProxy.MathService"
name="BasicHttpBinding_MathService" />
<endpoint
address="http://localhost:8081/HelloService"
binding="basicHttpBinding"
contract="HelloProxy.IHello"
name="BasicHttpBinding_IHello" />
</client>
</system.serviceModel>
</configuration>

Las clases de proxy se encuentran ocultas en el Explorador de soluciones. Esto se debe a que se trata de código generado que no debe ser modificado. Para verlas, haga clic en la solución ServiceClient y, a continuación, en el botón Mostrar todos los archivos en la barra de herramientas del Explorador de soluciones. Hecho esto, se puede expandir HelloProxy.map y MathProxy.map para poder consultar los archivos.

Una vez que tenemos las referencias de servicios configuradas, podemos crear una interfaz de usuario para poder probar estos últimos. Agregue tres cuadros de texto y dos botones a Form1 con los nombres que se muestran debajo de los controles en rojo. Proporcione los valores predeterminados de estos cuadros de texto para facilitar la prueba de las operaciones de los servicios.

Al hacer clic en SayNameButton,deseamos llamar el método SayHello desde HelloServicey pasar el contenido de NameTextBox como un parámetro. Se puede usar un MsgBox para mostrar los resultados. Al hacer clic en AddButton,deseamos llamar el método Add de MathServicey pasar el contenido de XTextBox e YTextBox convertidos a Integercomo parámetros. Después, se puede usar un MsgBox para mostrar los resultados.

PublicClass Form1

PrivateSub SayNameButton_Click( _
ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles SayNameButton.Click
Using ws AsNew HelloProxy.HelloClient
MsgBox(ws.SayHello(NameTextBox.Text))
End Using
EndSub

PrivateSub AddButton_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles AddButton.Click
Dim x AsInteger = Integer.Parse(XTextBox.Text)
Dim y AsInteger = Integer.Parse(YTextBox.Text)

Using ws AsNew MathProxy.MathServiceClient
MsgBox(ws.Add(x, y).ToString())
End Using
EndSub

EndClass

Al ejecutar el cliente, debemos asegurarnos de que el host de la consola también se ejecuta (debe ser así para poder escuchar las solicitudes realizadas a HelloService).). Para ello, se pueden usar diversos proyectos de inicio. Haga clic con el botón secundario en la solución y elija Propiedades. Configure las propiedades de inicio tal como se muestra a continuación y haga clic en Aceptar.

Finalmente, ya estamos preparados para ejecutar el cliente y probar los servicios. Presione F5 para iniciar el cliente y el host de la consola, y haga clic en los botones. Si todo el proceso se llevó a cabo correctamente, deberá obtener los resultados siguientes (bajo el supuesto que usó los valores que se mostraban en la captura de pantalla anterior).

Fuente: http://msdn2.microsoft.com/

Escrito Por Rob Windsor, MVP de Visual Basic, de ObjectSharp Consulting.

Hábito N.º 1: Asumir la responsabilidad

Es una variante del clásico comentario “No hay bala de plata” que hizo hace más de 25 años Fred Brookes en The Mythical Man Month (en inglés). Procurar mecanismos de seguridad adecuados en su producto depende totalmente de usted. Nadie más (ni, por supuesto, ningún lenguaje de programación ni herramienta mágica) puede solucionar todas las lagunas de seguridad. No quiero que me malinterpreten: me gustan las herramientas de análisis de código fuente, pero no solucionarán mágicamente todas las vulnerabilidades de seguridad. Sólo usted puede hacerlo.

Los productos seguros son generados por desarrolladores que crean diseños seguros y escriben código seguro. Por último la escritura de código es un esfuerzo individual. El programador no puede ser reemplazado por una herramienta. Así pues, la seguridad de su producto es responsabilidad suya. Los gusanos Blaster y CodeRed se aprovechaban de código escrito por individuos (consulte la figura 1).

figura 1 código vulnerable son escritos por individuos

Recuerde que todo el código será examinado y, posiblemente, atacado. No hay ningún problema. Ser atacado es algo perfectamente normal. Lo importante es saber si su código quedará expuesto. Sólo usted puede determinar ese desenlace. Así pues, tómese en serio su código. Debe estar satisfecho con la calidad del código y poder dormir tranquilo sabiendo que, si es atacado, habrá hecho todo lo posible para impedir que lo dejen para el arrastre.

Si es posible, solicite a un experto de seguridad que revise su código. No pida que lo examine alguien sin experiencia en seguridad con la expectativa de que pueda encontrar errores de seguridad y vulnerabilidades. Procure por todos los medios recurrir a alguien que sepa realmente lo que tiene entre manos para que examine el código.

Y sea razonablemente humilde para pedir ayuda cuando la necesite. Antes comentaba que no debe confiar exclusivamente en las herramientas, pero no cabe duda de que debe aprovechar las que se encuentren a su disposición. Ejecute todas las herramientas de análisis de código fuente disponibles y hágalo con frecuencia. Aproveche cualquier construcción de lenguaje defensivo posible y todos los trucos de biblioteca que estén a su disposición. En C#, por ejemplo, ajuste el código de red que ejecute el acceso a matrices, donde el índice de matriz se derive de una solicitud de red, en operadores comprobados, para detectar posibles errores aritméticos con enteros.

Hábito N.º 2: No confíe nunca en los datos

Lo he dicho millones de veces y volveré a decirlo: toda entrada es nociva hasta que se demuestre lo contrario. Si nos fijamos en las vulnerabilidades de seguridad más atroces, veremos que comparten un rasgo común: el desarrollador confió en los datos entrantes. El problema es que, si el código asume que el formato de los datos es correcto, ¿qué ocurre si usted se equivoca con esa suposición? Si es su día, la aplicación se bloqueará. Con algo menos de suerte, el atacante podría introducir código malintencionado en sus procesos y causar estragos.

La ambigua definición de sistema seguro corresponde a la de aquél que realiza las tareas para las que está diseñado, ni más ni menos. Pero cuando surgen problemas derivados de la confianza en las entradas, el sistema suele verse obligado a desempeñar otras tareas. Un somero análisis de datos de Common Vulnerabilities and Exposures (CVE) (cve.mitre.org) muestra que, entre 2001 y 2004, el 47% de las vulnerabilidades de seguridad de las que CVE realizó un seguimiento fueron problemas relacionados con la confianza en las entradas. Los problemas más conocidos son saturaciones de búfer, errores aritméticos con enteros, secuencias de comandos entre sitios y errores de inyección SQL. Estamos empezando a ver nuevas variantes, como la inyección XPath y vulnerabilidades de inyección de protocolo ligero de acceso a directorios (LDAP).

Puede solucionar los problemas relacionados con la confianza en las entradas si aplica algunas normas simples. En primer lugar, no busque únicamente lo que le consta que tiene un efecto adverso; con ese planteamiento parte de la base de que conoce todo lo negativo y puede predecir lo que ocurrirá en el futuro. Buscar factores con efectos nocivos es una buena iniciativa siempre que no sea su único mecanismo de defensa. Una estrategia mejor consiste en restringir la entrada a lo que le consta que es adecuado. Con lenguajes de alto nivel, como C# y Perl, me gusta usar expresiones regulares para hacerlo.

A continuación, rechace lo que le conste que es perjudicial. Por ejemplo, si alguien solicita de forma remota un archivo a través de su código y el nombre del archivo incluye un carácter poco confiable (como : o \), rechace la solicitud. Y no le diga al atacante por qué; limítese a indicar “no se encontró el archivo”.

Por último, aunque esto no sirve en todas las situaciones, sanee los datos. Por ejemplo, en el caso de un servidor Web, debe codificar con HTML la salida procedente de una entrada potencialmente no fidedigna.

Hábito N.º 3: Diseñe amenazas contra su código

Dispone de modelos de amenazas, ¿verdad? Los modelos de amenazas le permiten comprender los riesgos potenciales para su software y asegurarse de que dispone de los remedios apropiados. Pero las ventajas del uso de modelos de amenazas no se limitan a un diseño seguro. Los modelos de amenazas pueden contribuir también a mejorar la calidad del código. Los modelos de amenazas le indican de dónde proceden los datos. ¿Se trata de datos locales o remotos? ¿Proceden los datos de usuarios anónimos o de usuarios de mayor confianza (autenticados), como los administradores?

Con esta información, puede determinar si sus defensas son apropiadas. Por ejemplo, el código al que pueden tener acceso usuarios anónimos y remotos tiene que ser muy seguro. No digo que el código al que sólo puedan tener acceso los administradores locales no debería ser seguro, sino que el código accesible de forma remota, sobre todo el que se ejecuta de manera predeterminada, debe ser a prueba de bombas; y eso implica más mecanismos de defensa, más revisiones y más atención a los detalles. Además, el modelo de amenazas puede indicarle la naturaleza de los datos que se protegen. Los datos empresariales de gran valor y la información personal identificable deben protegerse muy bien. ¿Son apropiadas sus defensas?

Asegúrese de que sus modelos de amenazas sean precisos y estén actualizados; después identifique todos los puntos de entrada en su código y clasifíquelos por accesibilidad: remotos o locales y usuarios con privilegios elevados frente a usuarios con pocos privilegios (o sin privilegios). El código más accesible debe revisarse en primer lugar y con mayor detenimiento. Por último, revise todo el código en las rutas de datos anónimos; dicho de otro modo, empiece por los puntos de entrada a los que se pueda tener acceso anónimamente y rastree los datos a lo largo de esa ruta, para asegurarse de que el código es correcto.

Hábito N.º 4: Vaya un paso por delante

El panorama de la seguridad evoluciona constantemente. Parece que cada semana hay nuevas variaciones con respecto a las cuestiones de seguridad. Esto significa que debe evolucionar y aprender acerca de nuevas amenazas y defensas, o sufrirá las consecuencias.

Algunas estrategias sencillas para mantenerse al día consisten en leer de vez en cuando algún buen libro sobre seguridad de software. Aprenda también de sus errores del pasado; mejor aún si se trata de los errores cometidos por otros. Para ello, puede leer bugtraq: vaya a securityfocus.com y regístrese para recibir mensajes de bugtraq en su bandeja de entrada. Pero acepte este pequeño consejo: cree una regla de la bandeja de entrada para mover los mensajes a una carpeta especial, de modo que pueda administrar el volumen. Es considerable.

Hábito N.º 5: Realice pruebas aleatorias

Las pruebas aleatorias permiten detectar errores de confiabilidad. Resulta que un porcentaje de los errores de confiabilidad corresponde a vulnerabilidades en la seguridad a la espera del “ataque adecuado”. Por supuesto, una saturación de búfer podría provocar el bloqueo de una aplicación; pero con una carga malintencionada bien diseñada, el atacante podría evitar el bloqueo y ejecutar código para sus propios fines. Nuestro lema para esos casos es “la denegación del servicio de hoy es la ejecución del código de mañana.”

Casi todos los errores o vulnerabilidades de análisis de archivos se detectaron por puro azar o por pruebas aleatorias. Microsoft ha detectado vulnerabilidades de seguridad analizando distintos formatos de archivo, como los correspondientes a archivos XLS, PPT, DOC y BMP. La mayoría de los fabricantes habían tenido vulnerabilidades similares, ya que el análisis de estructuras de datos complejas es una tarea complicada, el código complejo presentará errores y algunos de esos errores revelarán vulnerabilidades de seguridad.

Debe probar aleatoriamente todo el código que analice archivos y tráfico de red. El ciclo de vida de desarrollo de seguridad (SDL) de Microsoft es muy específico acerca de lo que esto significa para los formatos de archivo. Debe probar aleatoriamente todos los analizadores con 100.000 iteraciones de archivos con formato incorrecto mediante un comprobador aleatorio de archivos. Hay varios comprobadores aleatorios disponibles que funcionan correctamente, e incluimos un comprobador de archivos, así como código fuente C++, en el manual The Security Development Lifecycle (en inglés), que elaboré conjuntamente con Steve Lipner (microsoft.com/MSPress/books/8753.asp).

Una última nota acerca de las pruebas aleatorias. Si se bloquea el software, no crea que se trata de un bloqueo únicamente. Es probable que un porcentaje considerable de esos supuestos bloqueos estén invitando a que algún atacante escriba código malintencionado. Por lo tanto, no vea en un bloqueo “un mero bloqueo”.

Hábito N.º 6: No escriba código no seguro

En Microsoft usamos el concepto de puertas o compuertas de calidad para reducir las posibilidades de que un desarrollador introduzca código vulnerable en el producto. Estas “compuertas” ejecutan una batería de herramientas de análisis de código fuente en el código antes de proceder a su protección para señalar los problemas que pueda haber. Y los problemas identificados deben solucionarse antes de que se lleve a cabo la protección. También puede hacer que se apliquen reglas de código estrictas, como la exclusión del uso de funciones prohibidas, como la ausencia de llamadas a strcpy o strncat y el cifrado deficiente. (Microsoft ha prohibido más de 100 funciones de C en tiempo de ejecución para nuevo código). Por ejemplo, con relación al cifrado, no permitimos DES (la longitud de la clave es demasiado reducida), MD4 o MD5 (ya se han superado) en el código nuevo, a menos que un estándar del sector dicte su uso.

No reinvente funciones. Si tiene un código que analiza un formato de archivo determinado, no necesitará dos o tres conjuntos de código de análisis; aténgase a un conjunto, consolídelo y ajústelo de manera que pueda usarse en varios proyectos.

Por último, recuerde que las herramientas no son un sustituto para la escritura de código seguro. Por eso es tan importante la formación en materia de seguridad y privacidad. Necesita una comprensión sólida de los conceptos para tomar decisiones en conciencia y adquirir nuevas percepciones, algo inasequible para las herramientas.

Hábito N.º 7: Reconozca la asimetría estratégica

Ésta es una de mis cuestiones preferidas. Recuerde que, como desarrollador de software, las estadísticas en materia de seguridad van contra usted. Yo suelo llamarlo “la ventaja del atacante y el dilema del defensor”. Necesitaría que el código y los diseños fueran correctos al 100% en todo momento, y eso es imposible. Para empeorar las cosas, debe alcanzar el insuperable objetivo con un presupuesto fijo y a tiempo, mientras tiene que considerar los requisitos de compatibilidad, accesibilidad y otras “ades”. Un atacante puede dedicar todo el tiempo que desee para localizar un error y después anunciar al mundo que su aplicación no es segura.

En el hábito N.º 6 señalé que debería dejar de escribir nuevo código inseguro. Para el hábito N.º 7 tiene que concentrarse en todo el código, porque los atacantes no hacen distinciones en lo que respecta a la antigüedad. Dedique tiempo a revisar vulnerabilidades en el código antiguo, y considere seriamente la posibilidad de desechar funciones antiguas e inseguras. Si usa métodos de desarrollo ágiles, debe pensar en dedicar esfuerzos a corregir código antiguo para situarlo en el nivel de calidad del código más reciente.

Hábito N.º 8: Use las mejores herramientas que pueda

Por último, use las mejores herramientas que le sea posible. Me encantan las herramientas de análisis de código fuente y la tecnología que me ayuda a escribir código más seguro. Como señalé antes, las herramientas no son la panacea, pero ayudan. Y mucho. Las herramientas también facilitan la racionalización del problema del análisis de código fuente. Las herramientas pueden explorar grandes cantidades de código con rapidez, mucho más que una persona. Y esto le ayuda a hacerse una idea de lo “malo” que puede llegar a ser un determinado código.

Uno de mis trucos preferidos consiste en compilar código con los niveles de advertencia más altos que sea posible; por ejemplo, /W4 cuando uso Visual C++^® o –Wall cuando uso gcc. Si ve un gran número de advertencias en el código, quizá éste presente otros errores que no detectaron el compilador u otras herramientas. Ese código debería someterse a un escrutinio más detenido antes de su lanzamiento (consulte el hábito N.º 3).

Éstos son ocho buenos hábitos que se han observado en desarrolladores a los que se respeta enormemente, y que trabajan tanto para Microsoft como para otros fabricantes. Por sí solos, los hábitos no le convertirán en un desarrollador seguro estelar, pero no cabe duda de que le ayudarán.

Fuente:

http://msdn.microsoft.com/msdnmag/issues/06/11/SecureHabits/default.aspx?loc=es

By Michael Howard.

Crear la tabla de la base de ‘Usuarios’:

Esta sección del recorrido guiado le permitirá crear una Aplicación Web ASP.NET de principio a fin. La aplicación del escenario que generaremos ofrece servicios de reporte de pedidos para los clientes registrados.

En este recorrido, usted creará una nueva base de datos llamada Usuarios en la base de datos MatrixOrders. Después, utilizaremos esta tabla de la base de datos para almacenar los nombres de usuarios/contraseñas de los clientes registrados — y utilizaremos el sistema integrado de Autenticación de los formularios ASP.NET para permitir que los usuarios inicien su sesión.

1. Conéctese a la base de datos MatrixOrders creada en la sección previa del recorrido guiado.
2. Haga clic en el nodo Tablas en la vista de árbol de la ventana Datos y haga clic en el botón Nuevo objeto de la base de datos en la barra de herramientas de la ventana Datos.
3. Se le pedirá que introduzca un nuevo nombre de la tabla de base de datos. Escriba Usuarios en el cuadro de texto.
4. El Proyecto de la Matriz Web ASP.NET creará la nueva tabla Usuarios y la agregará al nodo Tablas en la ventana Datos.
5. La tabla Usuarios se abrirá en la vista Diseño y se creará con una columna predeterminada llamada Column0.
6. Con Column0 aún seleccionado, establezca las siguientes propiedades con los valores indicados a continuación:
   • Nombre: UserId
   • IsIdentity: Verdadero
   • InPrimaryKey: Verdadero
   • IsUniqueKey: Verdadero
7. Agregue una segunda columna a la tabla Usuarios (al hacer clic en el botón Agregar nueva columna ).
8. Con la columna recien creada aún seleccionada, establezca las siguientes propiedades a los valores indicados a continuación:
   • Nombre: UserName
   • Tipo de datos: varchar
   • Tamaño: 8
9. Agregue una tercera columna a la tabla Usuarios y establezca las siguientes propiedades con los valores indicados a continuación:
   • Nombre: UserPassword
   • Tipos de datos: varchar
   • Tamaño del campo: 25
10. Oprima Ctrl+S o haga clic en el Archivo->Guardar en el menú para guardar la tabla Usuarios.

Introducir los datos del Usuario: En este recorrido, usted agregará datos a la tabla Usuarios en la base de datos MatrixOrders que se creó en el recorrido anterior.

1. Haga clic en la pestaña Datos (localizada en la parte inferior de la ventana de la tabla Usuarios ).
2. Agregue dos nuevas filas de datos a la tabla Usuarios .
   Nota Oprima la tecla Intro o seleccione una fila diferente en la cuadrícula de datos para agregar una nueva fila a la base de datos. Nota La columna UserID está configurada para aumentar automáticamente (se inicia con 1 y va aumentando de 1 en 1 ). Automáticamente, la base de datos determina y asigna el siguiente valor para un campo de incremento automático cuando se genera una nueva fila en la base de datos. Los valores del campo de incremento automático son sólo de lectura y tendrán un valor negativo hasta que se agregue la nueva fila a la base de datos. Nota  Usted no puede editar la definición en una tabla si existen datos en la misma.
3. Cierre la ventana de la tabla Usuarios .

Crear la página de datos maestros / de detalle:

En este recorrido, usted creará una nueva Página de datos con base en la plantilla del proyecto Cuadrícula maestra – de detalle. Usted unirá la Página de datos con los Pedidos y las tablas OrderDetails en la base de datos Pedidos.

1. Seleccione Nuevo del menú Archivo. Usted verá que aparece el cuadro Agregar nuevo archivo.
2. Seleccione Páginas de datos del panel Plantillas.
3. Seleccione la plantilla Cuadrícula maestra – de detalle.
4. Escriba la ruta del archivo en el cuadro Ubicación.
5. Escriba Default.aspx en el cuadro Nombre de archivo.
6. Seleccione Visual Basic en el cuadro desplegable Lenguaje.
7. Haga clic en Aceptar. El archivo Default.aspx se abrirá en la vista Diseño.
8. Seleccione la pestaña Código. Nota: Automáticamente, la matriz Web ASP.NET ha colocado códigos para unir MasterGrid a una subrutina llamada BindMasterGrid y DetailsGrid a otra llamada BindDetailGrid.
9. Modifique las variables ConnectionString y CommandText en la subrutina BindMasterGrid, de lal manera que hagan referencia a las columnas en la tabla Pedidos en la base de datos MatrixOrders.

   Dim ConnectionString As String = “server=(local);database=MatrixOrders;Integrated” &_
   ” Security=SSPI”

   Dim CommandText As String = “select OrderID, OrderDate, CustomerName from Orders”

10. Modifique las variables ConnectionString y CommandText en la subrutina BindDetailGrid, de tal manera que hagan referencia a las columnas en la tabla OrderDetails en la base de datos Pedidos.

    Dim ConnectionString As String = “server=(local);database=MatrixOrders;Integrated ” &_
    “Security=SSPI”

    Dim CommandText As String = “select OrderDetailID, ProductName, Quantity, UnitPrice ” & _
    “from OrderDetails where OrderID = ‘” & filterValue & “‘”

11. Seleccione la pestaña Diseño.
12. Establezca la propiedad DataKeyField de MasterGrid en OrderID. La propiedad DataKeyField se utiliza para filtrar las filas en la cuadrícula de detalle.
13. Reemplace el texto del encabezado de la página predeterminada (Cuadrícula maestra – de detalles) con el control Etiqueta de la pestaña Controles Web en el Cuadro de herramientas.
14. Establezca la propiedad ID de la Etiqueta a Bienvenida.
15. Seleccione la pestaña Código.
16. Modifique el método del manejador de eventos Page_Load al agregar el siguiente subprograma con código resaltado. El subprograma con código resaltado establece la propiedad Texto de la Etiqueta con el nombre del usuario del usuario actual:

    Sub Page_Load(Sender As Object, E As EventArgs)
    Welcome.Text = “Hello,” + User.Identity.Name
    If Not Page.IsPostBack Then
    ‘ Databind the master grid on the first request only
    ‘ (viewstate will restore these values on subsequent postbacks).
    MasterGrid.SelectedIndex = 0
    BindMasterGrid() BindDetailGrid()
    End If
    End Sub

17. Guarde y ejecute la página ASP.NET.
18. Su página ASP.NET aparecerá automáticamente en una nueva instancia de su explorador Web. Seleccione una fila en MasterGrid. Observe como DetailsGrid se actualiza con cada fila MasterGrid seleccionada. Observe que el nombre de usuario puede o no mostrarse dependiendo de las configuraciones de seguridad de su sistema de archivos. De manera predeterminada en la mayoría de los servidores, no aparecerá el nombre del usuario — debido a que un usuario que acceda a la página no necesita iniciar la sesión para verla (se permite un acceso anónimo). Cambiaremos estas configuraciones predeterminadas en los siguientes recorridos para obligar a los usuarios a iniciar la sesión.
19. Cierre la instancia del explorador Web.

Crear la Página de inicio de sesión: En este recorrido, usted creará una nueva página de inicio de sesión de la aplicación basado en la plantilla del proyecto Página de inicio de sesión. Usted validará a las credenciales de inicio de sesión de un usuario contra la tabla Usuarios en la base de datos MatrixOrders.

1. Seleccione Nuevo del menú Archivo. Usted verá aparecer el cuadro Agregar nuevo archivo.
2. Seleccione Seguridad del panel Plantillas.
3. Seleccione la plantilla Página de inicio de sesión.
4. Escriba una ruta de archivo en el cuadro Ubicación.
5. Escriba Login.aspx en el cuadro Nombre de archivo.
6. Seleccione Visual Basic en el cuadro desplegable Lenguaje.
7. Haga clic en Aceptar. El archivo Login.aspx se abrirá en la vista Diseño.
8. Seleccione la pestaña Código. Nota: El Proyecto de matriz Web ASP.NET ha reemplazado automáticamente el código en el evento LoginBtn_Click para validar los valores UserName y UserPass:

   Sub LoginBtn_Click(Sender As Object, E As EventArgs)
   If Page.IsValid Then
   If (UserName.Text = “jdoe@somewhere.com“) And (UserPass.Text = “password“) Then
   FormsAuthentication.RedirectFromLoginPage(UserName.Text, true)
   Else
   Msg.Text = “Invalid Credentials: Please try again”
   End If
   End If
   End Sub

9. De la pestaña Asistentes del código en el Cuadro de herramientas, arrastre un Asistente del código SELECCIONAR el Método de datos en la página ASP.NET.
10. Usted verá que aparece el cuadro Asistente Seleccionar el código de datos.
11. Seleccione la base de datos (local).MatrixOrders del cuadro desplegable Seleccione una base de datos.
12. Haga clic en Siguiente.
13. Seleccione Usuarios en la vista Tablas.
14. Seleccione el cuadro junto al elemento * en la vista Columnas.
15. Haga clic en DONDE.
16. Usted verá que aparece el cuadro Generador de cláusula DONDE.
17. Seleccione la tabla Usuarios en el menú desplegable Tabla en el panel Operando izquierdo.
18. Seleccione UserName en la vista Columna. Nota Esta opción establece la porción Operando izquierdo en la cláusula DONDE.
19. Seleccione el botón de radio Filtro y escriba @nombredelusuario en el cuadro filtro (predeterminado). Nota Esta opción establece la porción Operando derecho de la cláusula DONDE. Usted pasará este valor como un parámetro a la cláusula DÓNDE posteriormente en este recorrido.
20. Haga clic en Aceptar.
21. Usted regresará al paso Construya una Consulta SELECCIONAR en el Asistente generador de código.
22. Haga clic en Y Cláusula.
23. Usted verá que aparece el cuadro Generardor de consultas.
24. Seleccione la tabla Users en el menú desplegable Tabla en el panel Operando izquierdo.
25. Seleccione UserPassword en la vista Columna. Nota Esta opción establece la porción Operando izquierdo de la cláusula DONDE.
26. Seleccione el botón de radio Filtro y escriba @Contraseñadelusuario en el cuadro filtro (predeterminado). Nota Esta opción establece la porción Operando derecho de la cláusula DONDE. Usted pasará este valor como un parámetro a la cláusula DÓNDE posteriormente en este recorrido.
27. Haga clic en Aceptar.
28. Usted regresará al paso Construya SELECCIONAR consulta en el Asistente Generador de código.
29. Haga clic en Siguiente.
30. Usted verá que aparece el paso tres del Asistente Seleccionar código de datos; Vista previa de consulta.
31. Haga clic en Consulta de la prueba.
32. Escriba bsmith en el cuadro UserName =.
33. Escriba bsmith en el cuadro UserPassword =.
34. Haga clic en Aceptar.
35. Usted verá la fila Usuarios correspondiente al UserName específico y UserPassword aparecerá en la cuadrícula de resultados del cuadro Vista previa de la consulta.
36. Haga clic en Siguiente.
37. Usted verá aparecer el paso cuatro del Asistente Seleccionar el código de datos; escriba GetUser en el cuadro nombre del método.
38. Seleccione el botón de radio DataSet.
39. Haga clic en Finalizar.
40. El Asistente se cerrará y la Matriz Web ASP.NET colocará una función llamada GetUser en la vista Código. La función acepta un userName y una userPassword como parámetros de entrada y devuelve un DataSet como el parámetro de salida. DataSet se llena con los datos de detalle del usuario para el userName y la userPassword específicos:

    Function GetUser(ByVal userName As String, ByVal userPassword As String) As System.Data.DataSet

    Dim connectionString As String = “server=’(local)’; trusted_connection=true; database=’MatrixOrders’“
    Dim dbConnection As System.Data.IDbConnection = New System.Data.SqlClient.SqlConnection(connectionString)

    Dim queryString As String = “SELECT [Users].* FROM [Users] “& _
    “WHERE (([Users].[UserName] = @UserName) AND ([Users"& _
    "].[UserPassword] = @UserPassword))“

    Dim dbCommand As System.Data.IDbCommand = New System.Data.SqlClient.SqlCommand
    dbCommand.CommandText = queryString
    dbCommand.Connection = dbConnection

    Dim dbParam_userName As System.Data.IDataParameter = New System.Data.SqlClient.SqlParameter
    dbParam_userName.ParameterName = “@UserName“
    dbParam_userName.Value = userName
    dbParam_userName.DbType = System.Data.DbType.String
    dbCommand.Parameters.Add(dbParam_userName)
    Dim dbParam_userPassword As System.Data.IDataParameter = New System.Data.SqlClient.SqlParameter
    dbParam_userPassword.ParameterName = “@UserPassword“
    dbParam_userPassword.Value = userPassword
    dbParam_userPassword.DbType = System.Data.DbType.String
    dbCommand.Parameters.Add(dbParam_userPassword)

    Dim dataAdapter As System.Data.IDbDataAdapter = New System.Data.SqlClient.SqlDataAdapter
    dataAdapter.SelectCommand = dbCommand
    Dim dataSet As System.Data.DataSet = New System.Data.DataSet
    dataAdapter.Fill(dataSet)

    Return dataSet

    End Function

41. Actualizar el método del manejador de eventos al hacer clic en el Botón y agregar los subprogramas de código resaltados de tal manera que valide la entrada del usuario contra los resultados de invocar la función GetUser:

    Sub LoginBtn_Click(Sender As Object, E As EventArgs)
    If Page.IsValid Then
    Dim userDS As New System.Data.DataSet
    userDS = GetUser(UserName.Text, UserPass.Text)
    If userDS.Tables(0).Rows.Count = 1 Then
    FormsAuthentication.RedirectFromLoginPage(UserName.Text, false)
    Else
    Msg.Text = “Invalid Credentials: Please try again”
    End If
    End If
    End Sub

42. Guarde y regrese a la página Inicio de sesión.
43. Su página de Inicio de sesión aparecerá automáticamente en una nueva instancia de su explorador Web.
44. Escriba bsmith en los cuadros Username y Password y haga clic en Inicio de sesión.
45. De manera predeterminada, la página Inicio de sesión enviará al usuario a la página llamada Default.aspx en un inicio de sesión exitoso.
46. Cierre la instancia del explorador Web.
47. Escriba bsmith en el cuadro de texto Username.
48. Escriba 1234 ó cualquier otro texto, excepto la contraseña correcta bsmith en el cuadro Contraseña.
49. Presione Intro.Nota La página de Inicio de sesión mostrará un mensaje de error si usted proporciona las credenciales que no existen en la tabla Usuarios.
50. Cierre la instancia del explorador Web.
51. Cierre la página Login.aspx .

Crear Archivo WebConfig:
En este recorrido, usted creará un archivo Web.config que se utilizará para configurar su Aplicación Web:

• Recopile las credenciales utilizando un formulario HTML directamente del cliente (esto es, una Autenticación basada en formularios)
• Evite el acceso de usuarios Web anónimos

Cuando se usa junto con la Página Login.aspx que acabamos de crear, nos permitirá obligar a los usuarios a iniciar la sesión exitosamente antes de visitar nuestra página de reporte de datos maestros / de detalle. Para permitir esto, siga los siguientes pasos:

1. Seleccione Nuevo del menú Archivo. Usted verá que aparece el cuadro Agregar nuevo archivo.
2. Seleccione (General) del panel Plantillas.
3. Seleccione la plantilla Web.Config.
4. Escriba una ruta de archivo en el cuadro Ubicación.
5. Escriba Web.config en el cuadro Nombre de archivo (predeterminado).
6. Haga clic en Aceptar. Se abrirá el archivo Web.Config.
7. Localice el siguiente subprograma de código.

   <!–

   La <autenticación> permite la configuración del modo de autenticación de seguridad
   utilizado por ASP.NET para identificar a un usuario entrante. Brinda soporte a el atributo “modo”
   con cuatro valores válidos: “Windows”, “Formularios”, “Contraseña” y “Ninguno”:

   La sección <formularios> es una subsección de la sección <autenticación>,
   y permite configurar los valores de autenticación utilizados cuando se activa la autenticación Formularios
   anterior:

   <authentication mode=”Windows”>

   <forms name=”.aspx AUTH”
   loginUrl=”login.aspx “
   protection=”Validation”
   timeout=”999999″ />

   </authentication>
   –>

8. Sin comentario para la etiqueta <autenticación>. El subprograma de código resultante debe ser:

   <!–

   La sección <autenticación> permite la configuración del modo de autenticación de seguridad
   utilizado por ASP.NET para identificar a un usuario entrante. Da soporte a un atributo de “modo”
   con cuatro valores válidos: “Windows”, “Formularios”, “Contraseña” y “Ninguno”:

   La sección <formularios> es una subsección de la sección <autenticación>,
   y permite configurar los valores de autenticación utilizados cuando se activa la autenticación Formularios
   anterior:

   –>

   <authentication mode=”Windows”>

   <forms name=”.aspx AUTH”
   loginUrl=”login.aspx “
   protection=”Validation”
   timeout=”999999″ />

   </authentication>

9. Localice el siguiente atributo de modo y establezca el atributo modo de la etiqueta autenticación en Formularios (el predeterminado es Ventanas). Esta sección establece las pólizas de autenticación de la aplicación:

   <authentication mode=”Windows”>

   <forms name=”.aspx AUTH”
   loginUrl=”login.aspx “
   protection=”Validation”
   timeout=”999999″ />

   </authentication>

10. La etiqueta de <autenticación> resultante de ser:

    <authentication mode=”Forms”>

    <forms name=”.aspx AUTH”
    loginUrl=”login.aspx “
    protection=”Validation”
    timeout=”999999″ />

    </authentication>

    
    Nota: La autenticación basada en Formularios es un servicio de autenticación ASP.NET que permite a las aplicaciones proporcionar su propia interfaz de inicio de sesión y hacer su propia verificación de credenciales.

    Nota: El atributo modo es sensible a mayúsculas y minúsculas. mode=”forms” no funcionará.

11. Sin comentarios para la etiqueta <autorización>.
12. Elimine las subetiquetas permitir (predeterminado) de la etiqueta autorización. Esta sección establece las políticas de autorización de la aplicación:

     

    <allow users="joeuser" />
    <allow roles="Admins" />

    Nota: Usted puede permitir o rechazar el acceso a los recursos de la aplicación por usuario o rol.

13. Establezca la sub-etiqueta negar de la etiqueta autorización en ? (la configuración predeterminada es *):

    <deny users=”?” />

    Nota: Además de los nombres de usuario o rol, usted puede especificar uno de los siguientes valores comodín: “*” significa todos, “?” significa anónimo. Negar el acceso de los usuarios anónimos a las páginas dentro del directorio bloquea a cualquier usuario que no haya iniciado la sesión al visitar una página — y en lugar de esto lo enviará a la página de inicio de sesión creada anteriormente. No tendrán acceso a ninguna página hasta que introduzcan adecuadamente su nombre de usuario/contraseña en la página inicio de sesión.

14. Guardar el archivo. Nota: Usted no puede ejecutar un archivo Web.config.
15. Cierre el archivo.

Crear la página Registro: En este recorrido, usted creará una nueva Página ASP.NET que guardará la información del nuevo usuario en la tabla Usuarios.

1. Seleccione Nuevo del menú Archivo. Usted verá que aparece el cuadro Agregar nuevo archivo.
2. Seleccione (General) desde el panel Plantillas (predeterminado).
3. Seleccione la plantilla Página ASP.NET (predeterminado).
4. Escriba la ruta del archivo en el cuadro Ubicación.
5. Escriba NewUser.aspx en el cuadro Nombre de archivo.
6. Seleccione Visual Basic en el cuadro desplegable Lenguaje (predeterminado).
7. Haga clic en Aceptar. El archivo NewUser.aspx se abrirá en la vista Diseño.
8. De la pestaña Controles Web en el Cuadro de herramientas, arrastre tres controles de Etiqueta, dos controles TextBox y un control Botón a la Página ASP.NET.
9. Establezca la propiedad Texto en la parte superior de Etiquetas en UserName:.
10. Establezca la propiedad Texto de la Etiqueta intermedia en UserPassword:.
11. Establezca la propiedad Texto en la parte inferior de Etiqueta para vaciarlo (sin texto).
12. Establezca la propiedad ID de la Etiqueta inferior en Mensaje.
13. Establezca la propiedad ID en la parte superior de TextBox en txtUserName.
14. Establezca la propiedad ID del botón TextBox en txtUserPassword.
15. Establezca la propiedad TextMode de la contraseña del usuario TextBox en Contraseña. Nota Esta propiedad obtiene o establece el modo de comportamiento del cuadro de texto. En esta instancia, debido a que la contraseña es sensible a la información, TextBox cubrirá automáticamente la entrada del usuario.
16. Seleccione la pestaña Código.
17. De la pestaña Asistentes de código en el Cuadro de herramienta, arrastre un Asistente de código INSERTAR el Método de datos a la Página ASP.NET.
18. Usted verá que aparece el paso uno del Asistente INSERTAR el código de datos; el cual invoca el cuadro Seleccione una conexión de base de datos.
19. Seleccione la base de datos MatrixOrders y después haga clic en Siguiente.
20. Usted verá que aparece el paso dos del Asistente INSERTAR el código de datos; el cual invoca el cuadro Construir una Consulta INSERTAR.
21. Seleccionar Usuarios en la vista Tablas. Nota Deje los cuadros de Columna en sus valores predeterminados.
22. Haga clic en Siguiente.
23. Usted verá que aparece el paso tres de Asistente INSERTAR el código de datos; el cual invoca el cuadro Método del nombre. Escriba AddUser en el cuadro nombre del método.
24. Haga clic en Finalizar.
25. El Asistente se cerrará y la Matriz Web ASP.NET colocará una función llamada AddUser en la vista Código. La función acepta un userName y una userPassword como parámetros de entrada y devuelve un Integral como parámetro de salida. El valor Integral representará el número total de las filas afectadas:

    Function AddUser(ByVal userName As String, ByVal userPassword As String) As Integer

    Dim connectionString As String = “server=’(local)’; trusted_connection=true; database=’MatrixOrders’“
    Dim dbConnection As System.Data.IDbConnection = New System.Data.SqlClient.SqlConnection(connectionString)

    Dim queryString As String = “INSERT INTO [Users] ([UserName],“& _
    “[UserPassword]) VALUES (@UserName, @UserPassword)“

    Dim dbCommand As System.Data.IDbCommand = New System.Data.SqlClient.SqlCommand
    dbCommand.CommandText = queryString
    dbCommand.Connection = dbConnection

    Dim dbParam_userName As System.Data.IDataParameter = New System.Data.SqlClient.SqlParameter
    dbParam_userName.ParameterName = “@UserName“
    dbParam_userName.Value = userName
    dbParam_userName.DbType = System.Data.DbType.String
    dbCommand.Parameters.Add(dbParam_userName)
    Dim dbParam_userPassword As System.Data.IDataParameter = New System.Data.SqlClient.SqlParameter
    dbParam_userPassword.ParameterName = “@UserPassword“
    dbParam_userPassword.Value = userPassword
    dbParam_userPassword.DbType = System.Data.DbType.String
    dbCommand.Parameters.Add(dbParam_userPassword)

    Dim rowsAffected As Integer = 0
    dbConnection.Open
    Try
    rowsAffected = dbCommand.ExecuteNonQuery
    Finally
    dbConnection.Close
    End Try

    Return rowsAffected

    End Function

26. Seleccione la pestaña Diseño.
27. Haga doble clic en el control Botón. El Proyecto de Matriz Web ASP.NET abrirá la vista Código en el evento Button1_Click.
28. Agregue el subprograma de código en rojo al cuerpo del evento hacer clic en Botón de tal manera que invoque la función AddUser, pasando los valores TextBox como los parámetros UserName y UserPassword:

    Sub Button1_Click(sender As Object, e As EventArgs)

    If AddUser(txtUserName.Text, txtUserPassword.Text) > 0
    Message.Text = “Success”
    Else
    Message.Text = “Failure”
    End If

    End Sub

29. Abra el archivo web.con fig.
30. Agregue el subprograma del código en rojo a la etiqueta <configuración>, eso permitirá que todos tengan acceso a la Página NewUser.aspx .Nota: Coloque el subprograma del código fuera de las etiquetas <system.web>…</system.web>

    <location path=”NewUser.aspx “>
    <system.web>
    <authorization>
    <allow users=”*” />
    </authorization>
    </system.web>
    </location>

31. Guarde y cierre el archivo web.con fig.
32. Guarde y ejecute la Página ASP.NET NewUser.aspx.
33. Su página ASP.NET aparecerá automáticamente en una nueva instancia de su explorador Web.
34. Escriba el nuevo nombre del usuario en el cuadro UserName.
35. Escriba una contraseña al usuario en el cuadro UserPassword.
36. Haga clic en el Botón. Nota La Etiqueta del mensaje contendrá el estado para insertar el nuevo usuario.
37. Cierre la instancia del explorador Web.
38. Abra el archivo Login.aspx que desarrolló anteriormente en este recorrido. Así, usted proporcionará al usuario la opción de ejecutar la Página NewUser.aspx si están incorrectas sus credenciales de inicio de sesión.
39. Seleccione la pestaña Código.
40. Modifique el código del evento Hacer clic en el botón Inicio de sesión de tal manera que proporcione un vínculo a la Página New User en el texto Etiqueta del mensaje:

    Msg.Text = “Invalid Credentials: Please try again or ” + _ “<a ref=’newuser.aspx ‘>register a new user</a>”

41. Guarde y ejecute la Página ASP.NET.
42. Su página ASP.NET aparecerá automáticamente en una nueva instancia de su explorador Web.
43. Escriba un nombre de usuario inválido en el cuadro UserName.
44. Escriba una contraseña del usuario en el cuadro UserPassword.
45. Haga clic en el Botón. Nota Ahora el usuario tiene la opción de proporcionar las credenciales válidas del inicio de sesión o seguir el vínculo registrar un nuevo usuario.
46. Cierre la instancia del explorador Web.
47. Cierre el Proyecto de la Matriz Web ASP.NET.

Ejecutar la aplicación: En este recorrido, usted ejecutará la Aplicación Web desarrollada en este recorrido. El punto de entrada a la aplicación es la página Predeterminada.

1. Abra el archivo Default.aspx .
2. Ejecute la página ASP.NET.
3. Su página ASP.NET aparecerá automáticamente en una nueva instancia de su explorador Web.
4. Debido a que es la primera vez en la que ha accedido al sitio, no tendrá acceso a la página (ya que no ha iniciado la sesión). Automáticamente, ASP.NET lo enviará a la página de inicio de sesión — en donde puede introducir sus credenciales existentes de nombre de usuario/contraseña — o hacer clic en el vínculo del registro para crear una nueva cuenta. Una vez que ha iniciado la sesión, podrá regresar a la página default.aspx en donde tendrá acceso al sitio restringido.

Fuente: Universiadad .net
http://www.microsoft.com/spanish/msdn/comunidad/uni.net/