XML, Distribución y Componentes

Tema 7 – .NET Enterprise Services y Mensajería

http://paginaspersonales.deusto.es/dipina/MasterISW/

Dr. Diego Lz. de Ipiña Gz. de Artazahttp://paginaspersonales.deusto.es/dipina (Personal)

http://www.morelab.deusto.es (Research Group)http://www.smartlab.deusto.es (Research Lab)

http://www.ctme.deusto.es (Cátedra de Telefónica Móviles)http://www.tecnologico.deusto.es (Tecnológico-Fundación Deusto)

2/30

Temario

Procesamiento XML en .NET (21 y 22 Febrero) Estándar .NET [XML.NET] Soporte XML [XML-SAX, XML-DOM, Validación] XSL [XPath, XSLT, Scripts, Objetos de extensión]

Aplicaciones distribuidas (23 Febrero, 5 Marzo) XML/SOAP .NET Remoting Mensajería

Componentes .NET (6 y 7 Marzo) Metadatos y Reflexion Componentes .NET y Enterprise Services Complementos Interoperabilidad COM y P/Invoke COM+ y MTS MSMQ (colas de mensajes)

3/30

Contenidos Parte Aplicaciones Distribuidas

WebServices y SOAP .NET Remoting .NET Enterprise Services y Mensajería

4/30

Enterprise Services

Los enterprise services son un mecanismo que permite a las clases de .NET acceder a los servicios COM+

Algunos ejemplos de servicios COM+ son: Activación Just-in-Time (JIT) Sincronización Pools de Objetos Transacciones Gestión de Propiedades Compartidas Para construir aplicaciones web flexibles:

Manejo de eventos Componentes basados en colas Seguridad basada en reglas

El espacio de nombres System.EnterpriseServices provee acceso a atributos propietarios y clases para acceder estos servicios desde código manejado.

5/30

Gestión de Servicios

Toda servicio de componentes es una clase escrita en un lenguaje CLS que deriva de la clase System.EnterpriseServices.ServicedComponent

Para usar estos servicios aplicas atributos relacionados a servicios y creas instancias de clases que usan esos servicios.

El catálogo COM+ mantiene información de configuración que aplicas a la implementación de una clase. COM+ crea una capa de contexto de servicio en base a estos

atributos.

6/30

Pasos para Crear Un Servicio de Componente I

1. Define una clase que deriva de la clase ServicedComponentusing System.EnterpriseServices; public class Account : ServicedComponent { static void Main() {} }

2. A continuación se declaran atributos a los servicios del ensamblado, clase o método:using System.EnterpriseServices;[Transaction(TransactionOption.Required)]public class Account : ServicedComponent { [AutoComplete] static void Main() {} }

3. Añadir el atributo [assembly: ApplicationName("ComPlusApp")] encima de la declaración de la clase para que "COMPlusApp" se registre en el catálogo COM+.

4. Añadir el atributo para dar un nombre fuerte al ensamblado [assembly: AssemblyKeyFile("ComPlus.snk")]

5. Generar un nombre seguro usando: sn -k ComPlus.snk

7/30

Pasos para Crear Un Servicio de Componente II

6. Construye la aplicación registrará la aplicación en el catálogo COM+ (lazy register)csc /t:exe /r:System.EnterpriseServices.dll Demo.cs

7. Registra el servicio usando registro dinámico o manual8. Usar el registro creando instancias del componente En la mayoría de los casos Lazy Registration fallará ya que requiere

derechos de administrador. Los servicios de componentes serán registrados en la Global Assembly Cache porque son recursos a nivel de sistema.

1. gacutil.exe  -i app.dll     (o como se llame la dll) 2. regsvcs.exe app.dll 3. Crear un cliente que referencia a System.EnterpriseServices e invoca tus

métodos COM+ 4. Ejecútalo

8/30

Ejemplo Enterprise Services I

Ejemplo cuenta corriente La clase Account deriva de ServicedComponent, que asegura que el

contexto de los componentes Account es mantenido en COM+ Aplicaremos los siguientes atributos:

TransactionAttribute, se aplica a la clase Account para hacer que la transacción sea requerido

AutoCompleteAttribute, aplicado al método Post, instruye al Runtime a llamar a la función SetAbort si ocurre alguna excepción y si no a SetComplete

Varios atributos a nivel de ensamblado son utilizados para suministrar información de registro COM+

Un servicio de componente debe ser strong-named y debería situarse en el GAC para registro manual.

9/30

Ejemplo Enterprise Services II

using System.EnterpriseServices;using System.Runtime.CompilerServices;using System.Reflection;// Supply the COM+ application name.[assembly: ApplicationName("BankComponent")]// Supply a strong-named assembly.[assembly: AssemblyKeyFileAttribute("BankComponent.snk")]namespace BankComponent{ [Transaction(TransactionOption.Required)] public class Account : ServicedComponent { [AutoComplete] public bool Post(int accountNum, double amount) { /* Updates the database; no need to call SetComplete. Calls SetComplete

automatically if no exception is generated. */ return false; }

}}

10/30

Ejemplo Enterprise Services III

using System;using BankComponent;namespace BankComponentConsoleClient{ class Client { public static int Main() { try { Account act = new Account(); // Post money into the account. act.Post(5, 100); Console.WriteLine("¡Invocación a act.Post(5, 100) finalizada!"); return(0); } catch { return(1);

} }}

}

11/30

Ejemplo Enterprise Services IV

Compilación del ejemplo:

sn -k BankComponent.snkcsc /t:library /r:System.EnterpriseServices.dll Bank.cs

csc /r:Bank.dll BankClient.cs

12/30

Servicios COM+ Disponibles

Automatic Transaction Processing Aplica características de procesamiento de transacciones declarativas[Transaction(TransactionOption.Required,

Isolation=TransactionIsolationLevel.Serializable, Timeout=10)]

BYOT (Bring Your Own Transaction) Permite una forma de herencia de transacciones

Compensating Resource Managers (CRMs) Applies atomicity and durability properties to non-transactional resources.

Just-in-Time Activation Activates an object on a method call and deactivates when the call returns.

Loosely Coupled Events Manages object-based events. Object Construction Passes a persistent string value to a class instance on

construction of the instance. Object Pooling Provides a pool of ready-made objects. Private Components Protect components from out-of-process calls. Queued Components Provides asynchronous message queuing. Role-Based Security Applies security permissions based on role. SOAP Service Publishes components as XML Web services. Synchronization Manages concurrency.

13/30

Just-in-Time Activation

El servicio de activación COM+ Just-in-Time permite a los recursos del servidor ser usados más productivamente.

Cuando un componente es configurado como JITActivated, COM+ lo puede desactivar mientras un cliente mantiene una referencia al objeto. La siguiente llamada del cliente al objeto hará que COM+ lo reactive, de manera

transparente, just in time. Cuando se devuelve una invocación de un método, COM+ desactiva el objeto

pero deja el contexto en memoria. El objeto desactivado libera los recursos, incluyendo locks y otros recursos caros.

Para aplicar activación JIT usa el atributo JustInTimeActivationAttribute a una clase derivada de System.EnterpriseServices.ServicedComponent.

Para que el objeto se desactive después de la invocación de un método, se puede aplicar el atributo AutoCompleteAttribute a una clase o llamar a ContextUtil.SetComplete y ContextUtil.SetAbort. Para componentes no transaccionales usar ContextUtil.DeactivateOnReturn.

Ejemplo:[JustInTimeActivation] public class TestObjectPooling : ServicedComponent

14/30

Object Pooling

El servicio COM+ Object Pooling permite reducir la sobrecarga de crear objetos desde cero. Cuando un objeto se activa se recupera del pool. Cuando se desactiva, se encola en el pool para esperar a la siguiente

petición. Para configurar Object Pooling utiliza el atributo

ObjectPoolingAttribute en una clase derivada de System.EnterpriseServices.ServicedComponent.

Mientras que object pooling te permite controlar el número de conexiones utilizadas, connection pooling, controla el número máximo de conexiones alcanzadas.

15/30

Ejemplo Object Pooling Iusing System;using System.EnterpriseServices;using System.Runtime.CompilerServices;using System.Reflection;// Da un nombre a la aplicación COM+[assembly: ApplicationName("TestObjectPooling")]// Indica el nombre del strong-named assembly[assembly: AssemblyKeyFileAttribute("TestObjectPooling.snk")][ObjectPooling(Enabled=true, MinPoolSize=2, MaxPoolSize=5, CreationTimeout=20000)]public class TestObjectPooling : ServicedComponent{

public void Perform (){

// Method contents go here.Console.WriteLine("Ejecutando TestObjectPooling component");

}protected override void Activate(){

// Called when removed from the pool.}protected override void Deactivate(){

// Called before deactivating or placing back in pool.}protected override bool CanBePooled(){

// Called after Deactivate. Indicate your vote here.return true;

}}

16/30

Ejemplo Object Pooling II

using System;using System.EnterpriseServices;

public class App{ public static void Main(string[] args) { TestObjectPooling order = new TestObjectPooling(); order.Perform(); /* To return the object to the object pool, use

DisposeObject. This returns the object to the pool and allows it to be reused. If this call is not made, the garbage collector returns it to the pool in a non-deterministic fashion,

which hinders performance of an application that depends on

object pooling to conserve expensive resources. */ ServicedComponent.DisposeObject (order); }}

17/30

Ejemplo Object Pooling III

Pasos de compilación:1. sn -k TestObjectPooling.snk2. csc /t:library /r:System.EnterpriseServices.dll

ObjectPoolingService.cs3. csc /r:ObjectPoolingService.dll ObjectPoolingClient.cs

18/30

Loosely Coupled Events

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconlooselycoupledevents.asp

19/30

Referencias Enterprise Services

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconwritingservicedcomponents.asp

20/30

Atributos de Enterprise Services

Attribute Class Controls Applies To

AutoCompleteAttribute Auto-completion of declarative transactions Method

ComponentAccessControlAttribute Class-level access control Class

ConstructionEnabledAttribute Object construction (construct string) Class

EventTrackingAttribute Events and Statistics Class

JustInTimeActivationAttribute Just-in-time (JIT) activation Class

MustRunInClientContextAttribute Mandatory activation in client's context Class

ObjectPoolingAttribute Object pooling Class

SecurityRoleAttribute Role memberships and declarative tests Class

TransactionAttribute Declarative transactions Class

Attribute Class Controls

ApplicationAccessControlAttribute Security settings (except identity)

ApplicationActivationAttribute Activation mode, either library or server

ApplicationIDAttribute Unique ID

ApplicationNameAttribute Name

21/30

MSMQ

MSMQ ofrece un mecanismo alternativo para comunicarse con una aplicación remota enviando y recibiendo mensajes.

MSMQ garantiza el envío de mensajes Los mensajes que no pueden ser enviados se guardan hasta que el destinatario es

re-arrancado Destinado a soluciones que requieren mayor robustez que .NET Remoting o

Servicios Web Varios mensajes relacionados se pueden agrupar en una transacción

Las colas de mensajes se pueden clasificar en públicas, privadas y de sistema.

Tutorial en: http://www.15seconds.com/issue/031202.htm

22/30

Tipos de Colas

Colas públicas: es visible a través de la red y que puede ser accedido potencialmente por todas las máquinas participantes

Colas privadas: es visible sólo en la máquina local y accesible por aplicaciones que conocen el camino o nombre de la cola

Colas del sistema: pueden ser journal queues que guardan copias de mensajes, dead letter queues que guardan copias de mensajes no enviados o colas de informes.

23/30

.NET y MSMQ

Para trabajar con colas de mensajes usamos System.Messaging.MessageQueue

Por ejemplo, para crear una cola privada haríamos lo siguiente:using System.Messaging;…string qPath=@”.\Private$\PruebaQueue”;if (!MessageQueue.Exists(qPath)) MessageQueue.Create(qPath); // crea la colaMessageQueue q = new MessageQueue(qPath); // instancia

un objeto cola Ejemplo de cola pública serían:

q.Path = @”myMachine\PruebaQueue”

24/30

Formato de Mensajes

La propiedad Formatter de una cola para enviar y recibir tipos definidos por el usuario

Para enviar mensajes en formato XML, utilizaríamos un XmlMessageFormatter:q.Formatter = new XmlMessageFormatter(new string[]

{“Poker.Hand”});...// recibir un objeto Poker.HandPoker.Hand pokerHand = (Poker.Hand)q.Receive().Body;...// enviar un objeto Poker.Handq.Send(pokerHand);

25/30

Active Directory

http://www.microsoft.com/windows2000/technologies/directory/ad/default.asp

26/30

Leyendo Datos del Active Directory de Windows

// Ejecutar: ADRead.exe "LDAP://CN=Clarify Operations Team,OU=Distribution Lists,DC=redmond,DC=corp,DC=microsoft,DC=com" using System;using System.DirectoryServices;

public class ADRead { public static void Main(String[] args) { if(args.Length!=1) { Console.WriteLine("Uso: " + Environment.GetCommandLineArgs()[0] + " <ad_path>"); Console.WriteLine (); Console.WriteLine ("Presione Entrar para continuar..."); Console.ReadLine(); return; }

DirectoryEntry objDirEnt=new DirectoryEntry(args[0]); Console.WriteLine("Nombre = " + objDirEnt.Name); Console.WriteLine("Ruta de acceso = " + objDirEnt.Path); Console.WriteLine("Nombre de la clase de esquema = " + objDirEnt.SchemaClassName); Console.WriteLine(""); Console.WriteLine("Propiedades:");

foreach(String Key in objDirEnt.Properties.PropertyNames) { Console.Write("\t{0} = ", Key); Console.WriteLine(""); foreach(Object objValue in objDirEnt.Properties[Key]) { Console.WriteLine("\t\t{0}", objValue); } } }}

27/30

Modificando Datos del Active Directory de Windows

// ADWrite.exe "LDAP://DC=Microsoft,DC=COM" "name" "Microsoft" using System;using System.DirectoryServices;

public class ADWrite { public static void Main(String[] args) { if ( args.Length!=3 ) { Console.WriteLine("Uso: " + Environment.GetCommandLineArgs()[0] + " <ruta_de_acceso_ad>

<propiedad> <valor>"); Console.WriteLine (); Console.WriteLine ("Presione Entrar para continuar..."); Console.ReadLine(); return; } DirectoryEntry objDirEnt = new DirectoryEntry(args[0]); Console.WriteLine("Nombre = " + objDirEnt.Name); Console.WriteLine("Ruta de acceso = " + objDirEnt.Path); Console.WriteLine("Nombre de la clase de esquema = " + objDirEnt.SchemaClassName); Console.WriteLine(args[1] + " = " + (objDirEnt.Properties[args[1]][0]).ToString()); Console.WriteLine("... cambia a "); (objDirEnt.Properties[args[1]])[0] = args[2]; objDirEnt.CommitChanges(); Console.WriteLine(args[1] + " = " + (objDirEnt.Properties[args[1]][0]).ToString()); }}

28/30

Bibliografía

Understanding Enterprise Services in .NET http://www.gotdotnet.com/team/xmlentsvcs/espaper.aspx

.NET Enterprise Services and COM+ 1.5 Architecture http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnentsrv/

html/netenterpriseandcomplus.asp INFO: Roadmap for .NET Enterprise Services

http://support.microsoft.com/default.aspx?scid=kb;en-us;308672

29/30

Bibliografía

“COM+ Integration: How .NET Enterprise Services Can Help You Build Distributed Applications”

http://msdn.microsoft.com/msdnmag/issues/01/10/complus/default.aspx

XML, Distribución y Componentes

Tema 7 – .NET Enterprise Services y Mensajería – Preguntas y Sugerencias

Dr. Diego Lz. de Ipiña Gz. de Artazahttp://paginaspersonales.deusto.es/dipina (Personal)

http://www.morelab.deusto.es (Research Group)http://www.smartlab.deusto.es (Research Lab)

http://www.ctme.deusto.es (Cátedra de Telefónica Móviles)http://www.tecnologico.deusto.es (Tecnológico-Fundación Deusto)