Tema 7 – .NET Enterprise Services y Mensajería
Download
Report
Transcript Tema 7 – .NET Enterprise Services y Mensajería
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 Artaza
http://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)
Temario
Procesamiento XML en .NET (21 y 22 Febrero)
Aplicaciones distribuidas (23 Febrero, 5 Marzo)
Estándar .NET [XML.NET]
Soporte XML [XML-SAX, XML-DOM, Validación]
XSL [XPath, XSLT, Scripts, Objetos de extensión]
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)
2/30
Contenidos Parte Aplicaciones
Distribuidas
WebServices y SOAP
.NET Remoting
.NET Enterprise Services y Mensajería
3/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.
4/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.
5/30
Pasos para Crear Un Servicio de
Componente I
1.
Define una clase que deriva de la clase ServicedComponent
using 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.
4.
5.
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+.
Añadir el atributo para dar un nombre fuerte al ensamblado [assembly:
AssemblyKeyFile("ComPlus.snk")]
Generar un nombre seguro usando: sn -k ComPlus.snk
6/30
Pasos para Crear Un Servicio de
Componente II
Construye la aplicación registrará la aplicación en el catálogo COM+ (lazy
register)
csc /t:exe /r:System.EnterpriseServices.dll Demo.cs
Registra el servicio usando registro dinámico o manual
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.
6.
7.
8.
1.
2.
3.
4.
gacutil.exe -i app.dll (o como se llame la dll)
regsvcs.exe app.dll
Crear un cliente que referencia a System.EnterpriseServices e invoca tus
métodos COM+
Ejecútalo
7/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.
8/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;
}
}
}
9/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);
}
}
}
}
10/30
Ejemplo Enterprise Services IV
Compilación del ejemplo:
sn -k BankComponent.snk
csc /t:library
/r:System.EnterpriseServices.dll
Bank.cs
csc /r:Bank.dll BankClient.cs
11/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.
12/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
13/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.
14/30
Ejemplo Object Pooling I
using 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;
}
}
15/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);
}
}
16/30
Ejemplo Object Pooling III
Pasos de compilación:
sn -k TestObjectPooling.snk
2. csc /t:library /r:System.EnterpriseServices.dll
ObjectPoolingService.cs
3. csc /r:ObjectPoolingService.dll ObjectPoolingClient.cs
1.
17/30
Loosely Coupled Events
http://msdn.microsoft.com/library/default.asp?url=/
library/enus/cpguide/html/cpconlooselycoupledevents.asp
18/30
Referencias Enterprise Services
http://msdn.microsoft.com/library/default.asp?url=/
library/enus/cpguide/html/cpconwritingservicedcomponents
.asp
19/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
20/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
21/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.
22/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 cola
MessageQueue q = new MessageQueue(qPath); // instancia
un objeto cola
Ejemplo de cola pública serían:
q.Path = @”myMachine\PruebaQueue”
23/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.Hand
Poker.Hand pokerHand = (Poker.Hand)q.Receive().Body;
...
// enviar un objeto Poker.Hand
q.Send(pokerHand);
24/30
Active Directory
http://www.microsoft.com/windows2000/technolog
ies/directory/ad/default.asp
25/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);
}
}
}
}
26/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());
}
}
27/30
Bibliografía
Understanding Enterprise Services in .NET
.NET Enterprise Services and COM+ 1.5 Architecture
http://www.gotdotnet.com/team/xmlentsvcs/espaper.aspx
http://msdn.microsoft.com/library/default.asp?url=/library/enus/dnentsrv/html/netenterpriseandcomplus.asp
INFO: Roadmap for .NET Enterprise Services
http://support.microsoft.com/default.aspx?scid=kb;en-us;308672
28/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
29/30
XML, Distribución y
Componentes
Tema 7 – .NET Enterprise Services y
Mensajería – Preguntas y Sugerencias
Dr. Diego Lz. de Ipiña Gz. de Artaza
http://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)