Desarrollo de componentes en Visual Basic .NET

Descripción




Como desarrolladores de Microsoft® Visual Basic®, seguramente ya sabemos cómo desarrollar y utilizar componentes en nuestras aplicaciones. En Visual Basic .NET, podemos utilizar las nuevas características en tiempo de diseño para crear fácilmente componentes y extender sus funcionalidades.
En este módulo, aprenderemos a:

Describir los distintos tipos de componentes que pueden crearse en Visual Basic .NET.
Crear componentes que pueden ser utilizados por aplicaciones cliente gestionadas y no gestionadas.
Crear componentes con servicio
Crear clases de componentes
Crear controles de formularios Windows® Forms.
Utilizar hilos para crear aplicaciones con múltiples hilos de ejecución.

Descripción de los componentes



En Visual Basic .NET, podemos crear varios tipos de componentes accesibles tanto desde aplicaciones cliente gestionadas (las basadas en los servicios del entorno de ejecución del .NET Framework) y aplicaciones cliente no gestionadas (por ejemplo, las creadas en Visual Basic 6.0).
En esta lección, aprenderemos a:
Describir los tipos de componentes que podemos crear en Visual Basic .NET.
Utilizar módulos y clases como componentes.
Utilizar componentes basados en Visual Basic .NET en entornos no gestionados.
Explicar los principales conceptos de .NET Remoting.

Tipos de componentes




En Visual Basic .NET, podemos crear varios tipos de componentes distintos, incluyendo:
Estructuras
Módulos
Clases
Clases de componentes
Componentes con servicio
Controles de usuario
Estructuras
Podemos utilizar las estructuras como componentes declarándolas públicas cuando las definamos. Las estructuras soportan muchas de las características de las clases, incluyendo propiedades, métodos y eventos, pero son de tipo valor; por tanto, la gestión de la memoria es más eficaz. Las estructuras no soportan herencia.
Módulos
Podemos utilizar los módulos como componentes declarándolos públicos cuando los definamos. Declarar módulos públicos permite crear librerías de código que contienen rutinas útiles para múltiples aplicaciones. También podemos utilizar módulos para crear funciones reutilizables que no son de aplicación a un componente, clase o estructura concretos.
Si hemos utilizado las clases GlobalMultiUse o GlobalSingleUse en versiones anteriores de Visual Basic, el concepto de librería de código no nos resultará nuevo. Estas clases proporcionan la misma funcionalidad en Visual Basic .NET; el código cliente no necesita cualificar estas clases por el nombre de clase para invocar las funciones.

Clases
Podemos utilizar clases como componentes declarándolas públicas en un ensamblado. Podemos utilizar clases públicas desde cualquier aplicación cliente basada en .NET agregando una referencia al ensamblado del componente. Podemos extender la funcionalidad de las clases mediante mecanismos como propiedades, métodos y eventos. Las clases también son extensibles mediante la herencia, lo cual permite a las aplicaciones reutilizar la lógica existente en estos componentes.
Clases de componentes
Una clase se convierte en componente cuando se ajusta a un estándar para la interacción con componentes. Este estándar se proporciona a través de la interfaz IComponent. Cualquier clase que implemente la interfaz IComponent es un componente. Las clases de componentes permiten abrir la clase en un diseñador visual y permiten a la clase ser ubicada en otros diseñadores visuales.
Componentes con servicio
Los componentes con servicio derivan directa o indirectamente de la clase System.EnterpriseServices.ServicedComponent. Las clases configuradas de este modo son hospedadas por una aplicación de servicios de componentes y pueden automáticamente utilizar los servicios que ésta ofrece.
Controles de usuario
Los controles de usuario son componentes creados por un desarrollador para ubicarlos en formularios Windows Forms o Web Forms. Cada control de usuario tiene su propio conjunto de propiedades, métodos y eventos que lo hacen adecuado para un determinado uso. Podemos manipular controles de usuario en los diseñadores de formularios Windows Forms y Web Forms y escribir código para agregar controles de usuario dinámicamente en el entorno de ejecución, al igual que con los controles proporcionados como parte del .NET Framework.

Uso de módulos como componentes




En Visual Basic .NET podemos utilizar módulos como componentes fuera del ensamblado en el que están definidos. Para que esto sea posible, debemos declarar el módulo como público cuando lo definamos. A continuación, necesitaremos crear una referencia en el ensamblado cliente al ensamblado componente y utilizar la instrucción Imports para permitir el acceso a los métodos del módulo.
El siguiente ejemplo muestra cómo crear un módulo público denominado MyMathFunctions que define la función Square. Este módulo está definido en el ensamblado MyAssembly. A continuación, el módulo puede utilizarse como un componente en el código cliente, como muestra la segunda parte del ejemplo.
Public Module MyMathFunctions
Public Function Square(ByVal lng As Long) As Long
Return (lng * lng)
End Function
...
End Module
'Client code
Imports MyAssembly
...
Dim x As Long = Square(20)

Uso de clases como componentes




Podemos utilizar clases como componentes fuera del ensamblado en el que están definidas marcando la clase como pública. A continuación, referenciamos el ensamblado del componente desde el ensamblado cliente, y utilizamos la instrucción Imports para permitir el acceso directo a la clase.
El siguiente ejemplo muestra cómo crear una clase pública denominada Account que define los métodos Debit y Credit. Esta clase está definida en el ensamblado MyAssembly. A continuación, otro ensamblado cliente referencia el ensamblado, y la clase puede utilizarse por instancias de objetos.
Public Class Account
Public Sub Debit(ByVal AccountId As Long, Amount As Double)
'Perform debit action
End Sub
Public Sub Credit(ByVal AccountId As Long, Amount As Double)
'Perform credit action
End Sub
End Class
'Client code
Imports MyAssembly
Dim x As New Account( )
x.Debit(1021, 1000)

Uso de componentes en aplicaciones cliente no gestionadas



Podemos crear componentes con Visual Basic .NET que pueden ser utilizados por aplicaciones cliente no gestionadas. Esta interoperabilidad permite utilizar características de los servicios de componentes como la agrupación de objetos o las transacciones. Para exponer nuestros componentes a COM y a los servicios de componentes, debemos establecer propiedades específicas del ensamblado y crear nuestras clases adecuadamente.
Establecer propiedades del ensamblado
Debemos proporcionar a nuestro ensamblado un nombre seguro si deseamos que sea accesible desde código no gestionado. Para crear un ensamblado de nombre seguro, utilizaremos un par de claves privada y pública al generar la aplicación, para garantizar que el ensamblado es único y no puede modificarse de forma inadecuada después de que haya sido generado.
Poner nombre al ensamblado
Podemos generar un nombre seguro para nuestro ensamblado utilizando la herramienta de nombres seguros (sn.exe) incluida en el .NET Framework. El siguiente código muestra cómo utilizar sn.exe para generar un archivo de claves denominado KeyFile.snk:
sn.exe –k KeyFile.snk
Una vez generado el archivo de claves, podemos agregarlo al proyecto y referenciarlo en AssemblyInfo.vb utilizando el siguiente código:

De este modo, nuestro ensamblado tendrá un nombre seguro la próxima vez que lo generemos.

Registro del ensamblado
Podemos registrar automáticamente un ensamblado que necesita interoperabilidad con COM en la sección Propiedades de configuración de las páginas de propiedades del ensamblado. La sección Generar proporciona una casilla de verificación Registrar para COM Interop. Si la seleccionamos, nuestro ensamblado se registra con COM cuando se genere la próxima vez. Si regeneramos más veces nuestro ensamblado tras el registro inicial, primero se eliminará del registro antes de ser registrado de nuevo. Este proceso garantiza que el registro no contiene información desactualizada.
Exponer miembros de clases a COM y a los servicios de componentes
Crear una clase que tenga propiedades y métodos públicos no hace que los miembros de la clase estén accesibles en COM y en los servicios de componentes. A menos que expongamos los miembros de clase, la clase en sí será accesible, pero los métodos no serán accesibles excepto a través de late binding. Podemos exponer los miembros de clases y permitir early binding:
Definiendo una interfaz pública
Utilizando el atributo ClassInterface
Utilizando el atributo COMClass.
Definir una interfaz pública
Definir una interfaz pública e implementarla en nuestra clase pública permite que las aplicaciones cliente no gestionadas puedan ver y enlazarse a los métodos de la interfaz. Esta aproximación proporciona el modo más coherente y seguro de exponer componentes a COM ya que el uso de interfaces evita muchos problemas asociados al versionado.
El siguiente código muestra cómo crear una interfaz pública y, a continuación, utilizar la interfaz en una clase que estará accesible para aplicaciones cliente no gestionadas a través de COM:
Public Interface IVisible
Sub PerformAction( )
End Interface
Public Class VisibleClass
Implements IVisible
Public Sub PerformAction( ) _
Implements IVisible.PerformAction
'Perform your action
End Sub
End Class

Uso del atributo ClassInterface
El espacio de nombres System.Runtime.InteropServices proporciona el atributo ClassInterface. Este atributo permite crear una clase con una interfaz dual para que todos los miembros de la clase (y las clases base) estén accesibles automáticamente para aplicaciones cliente no gestionadas a través de COM. El siguiente código muestra cómo utilizar el atributo ClassInterface:
Imports System.Runtime.InteropServices

_
Public Class VisibleClass
Public Sub PerformAction( )
'Perform your action
End Sub
End Class
Uso del atributo COMClass
El espacio de nombres Microsoft.VisualBasic proporciona el atributo COMClass que podemos utilizar en una clase para exponer todos los miembros de clase públicos a COM. Visual Basic .NET proporciona un elemento de plantilla de clase denominado COM Class que podemos agregar a cualquier tipo de proyecto que utilice el atributo COMClass. Cualquier ensamblado que contenga este tipo de clase se registrará cuando sea generado y posteriormente regenerado.

Descripción de .NET Remoting



Las versiones anteriores de Visual Basic utilizaban COM y la versión distribuida de COM (DCOM) para comunicarse con componentes en diferentes procesos o con distintos equipos. Visual Basic .NET utiliza .NET Remoting para permitir la comunicación entre aplicaciones cliente y servidor a través de dominios de aplicaciones.
El .NET Framework proporciona varios servicios que se utilizan en remoto:
Los canales de comunicación son los responsables de transportar los mensajes a y desde aplicaciones remotas utilizando tanto un formato binario sobre un canal Transmission Control Protocol (TCP) como Extensible Markup Language (XML) sobre un canal Hypertext Transfer Protocol (HTTP).
Formateadores que codifican y decodifican mensajes antes de que sean transportados por el canal.
Objetos proxy que envían las invocaciones de métodos remotos al objeto adecuado.
Soporte para la activación remota de objetos y para la duración de objetos marshal-by-reference que se ejecutan en el servidor.
Objetos marshal-by-value que son copiados por el .NET Framework en el espacio del proceso en el cliente para reducir viajes de ida y vuelta entre procesos o entre equipos.


Creación de componentes con servicio




En esta lección, aprenderemos a:
Describir los requerimientos para hospedar componentes basados en .NET en una aplicación de servicios de componentes.
Habilitar el procesamiento de transacciones en nuestros componentes.
Utilizar la agrupación de objetos para mejorar el rendimiento de los objetos que necesitan recursos adicionales.
Utilizar atributos de seguridad para especificar cómo interactúan los componentes con la seguridad de los servicios de componentes.
Agregar constructores para controlar la inicialización de un componente.
Explicar cómo utilizar otros servicios de componentes, como la activación Just-In-Time, desde componentes Visual Basic .NET.
Establecer atributos a nivel de ensamblado para mejorar la instalación de nuestra aplicación.

Hospedar componentes en los servicios de componentes



System.EnterpriseServices si deseamos hospedar un componente Visual Basic .NET en una aplicación de servicios de componentes. Este espacio de nombres proporciona las principales clases, interfaces y atributos para comunicar con los servicios de componentes.
El espacio de nombres System.EnterpriseServices proporciona las siguientes características:
Característica
Uso
Clase ContextUtil
Esta clase se utiliza para participar en transacciones y para interactuar con información de seguridad.
La funcionalidad de esta clase es similar a la funcionalidad de la clase ObjectContext en Visual Basic 6.0.
Clase ServicedComponent
Todas las clases de componentes que necesitan ser hospedadas en una aplicación de servicios de componentes deben heredar de esta clase.
Esta clase define el tipo base para todos los tipos enlazados a contexto e implementa métodos similares a los que se encuentran en la interfaz IObjectControl utilizada en las aplicaciones de servicios de componentes basadas en Visual Basic 6.0.
Atributos de ensamblado, clase y método
Podemos definir varios atributos del ensamblado para la interrogación a los servicios de componentes en el archivo AssemblyInfo.vb. Estos valores se utilizan para establecer el nombre y la descripción de la aplicación y demás valores cuando la aplicación se instala como una aplicación de servicios de componentes.
El espacio de nombres System.EnterpriseServices también define varios atributos de clases y métodos, incluyendo TransactionAttribute, AutoCompleteAttribute, ObjectPoolingAttribute y ConstructionEnabledAttribute

Uso de transacciones



Con frecuencia, se requieren transacciones para mantener la integridad de los datos y sincronizar actualizaciones de datos entre múltiples fuentes de datos. Podemos habilitar el procesamiento de transacciones en los componentes con servicio incluyendo las clases y atributos adecuados en el código de nuestro componente.
Opciones del atributo Transacción
Utilizamos el atributo Transaction para especificar cómo una clase puede participar en las transacciones. Podemos establecer el soporte de transacciones con una de las siguientes opciones:
Opción
Efecto
Disabled
La instancia de clase no utilizará transacciones e ignorará las transacciones de objetos padre.
NotSupported
La instancia de clase no se creará en el contexto de una transacción.
Required
La instancia de clase se incluirá en una transacción existente proporcionada por el contexto del objeto que realiza la llamada. Si no existe ninguna transacción, se creará una.
RequiresNew
La instancia de clase siempre creará una nueva transacción con independencia de las transacciones ya creadas por objetos que realizan las llamadas.
Supported
La instancia de clase se incluirá en una transacción si la proporciona el contexto del objeto que realiza la llamada, pero no creará una transacción si no existe ya una.


Uso del atributo Transaction
El siguiente ejemplo define una clase Account y establece el atributo Transaction a Required.
Imports System.EnterpriseServices
Public Class Account
Inherits ServicedComponent
Public Sub Debit(ByVal id As Integer, _
ByVal amount As Double)
'Debit code
End Sub
End Class
Opciones de votación de una transacción
Podemos votar por el resultado de una transacción utilizando métodos de la clase ContextUtil, suministrada por el espacio de nombres System.EnterpriseServices. Esta clase estática proporciona muchos métodos y propiedades que nos resultarán familiares si hemos creado componentes que utilicen Microsoft Transaction Server (MTS) o los servicios de componentes. A continuación, se describen algunos de los métodos más habituales:
Método ContextUtil
Utilice este método para:
SetAbort
Votar por la anulación de una transacción. La transacción sólo puede tener éxito si todos los objetos implicados en la transacción votan satisfactoriamente por unanimidad. Este método también permite que el objeto sea desactivado después de que la llamada al método finalice.
SetComplete
Votar por la confirmación de una transacción. Si todos los objetos implicados en la transacción votan con éxito, la transacción puede completarse. Este método también permite que el objeto sea desactivado después de que la llamada al método finalice.
EnableCommit
Votar por una finalización exitosa de la transacción, no permitiendo al objeto ser desactivado después de que la llamada al método finalice.
Esta opción resulta útil si deseamos mantener el estado a través de múltiples llamadas a métodos, pero no necesitamos más acciones para finalizar con éxito la transacción si así lo solicita el componente de servicio de nivel superior.
DisableCommit
Votar por una finalización no exitosa de la transacción, no permitiendo al objeto ser desactivado después de que la llamada al método finalice.
Esta opción resulta útil si deseamos mantener el estado a través de múltiples llamadas a métodos y necesitamos que ocurran otras acciones antes de que la transacción pueda finalizar con éxito.

Uso de la clase ContextUtil
El siguiente ejemplo muestra cómo utilizar la clase ContextUtil para finalizar o abortar transacciones en el método Debit de la clase Account, basándose en las excepciones que se hayan encontrado.
Public Sub Debit(ByVal id As Integer, ByVal amount As Double)
Try
'Perform update to database
...
ContextUtil.SetComplete( )
Catch ex As Exception
ContextUtil.SetAbort( )
Throw ex
End Try
End Sub
Procesamiento de transacciones
Para evitar el uso de los métodos SetAbort y SetComplete de ContextUtil, podemos establecer el atributo AutoComplete de los métodos específicos del componente. Si no ocurren excepciones durante la ejecución del método, el objeto se comporta como si se hubiera invocado SetComplete. Si ocurren excepciones, el objeto se comporta como si se hubiera invocado SetAbort.
Uso del atributo AutoComplete
El siguiente ejemplo muestra cómo utilizar el atributo AutoComplete:
Public Sub Credit( _
ByVal fromAccount As Integer, ByVal amount As Double)
'Perform update to database
...
'No SetComplete or SetAbort is required
End Sub

Uso de la agrupación de objetos



En Visual Basic .NET, podemos utilizar el atributo ObjectPooling y la clase base ServicedComponent para crear componentes con servicio que utilicen la agrupación de objetos.
¿Qué es la agrupación de objetos?
La agrupación de objetos permite crear con antelación un número prestablecido de objetos, de modo que estén listos para ser usados por peticiones de clientes cuando la aplicación se inicia. Cuando una aplicación cliente realiza una petición de un objeto, se toma uno de la agrupación de objetos disponibles y se utiliza para esa petición. Cuando finaliza la petición, el objeto se devuelve a la agrupación para que pueda ser utilizado en otras peticiones de clientes.
Podemos utilizar la agrupación para mejorar el rendimiento de objetos que requieran grandes intervalos de tiempo para adquirir recursos y completar una operación. Los objetos que no necesiten tales recursos no se beneficiarán significativamente de la agrupación de objetos.

Habilitar la agrupación de objetos
Especificamos el atributo ObjectPooling para que los servicios de componentes puedan ubicar el componente en una agrupación de objetos. También podemos especificar argumentos opcionales del atributo para establecer los valores MinPoolSize y MaxPoolSize de la agrupación.
MinPoolSize
Utilizamos el argumento MinPoolSize para establecer el número mínimo de objetos que se crearán con antelación en la agrupación.
MaxPoolSize
Utilizamos el argumento MaxPoolSize para establecer el número máximo de objetos que pueden crearse en la agrupación.
• Si no hay objetos disponibles en la agrupación cuando se recibe una petición, la agrupación puede crear otra instancia del objeto si ese número máximo de objetos preestablecido no se ha alcanzado ya.
• Si ya se han creado el número máximo de objetos y actualmente no hay ninguno disponible, las peticiones se encolarán hasta el próximo objeto disponible.
Devolver objetos a la agrupación de objetos
Utilizamos el método CanBePooled para especificar si nuestro componente puede ser devuelto a la agrupación de objetos. Los objetos únicamente pueden devolverse a la agrupación cuando están desactivados. Esto ocurre cuando se invocan los métodos SetComplete o SetAbort cuando el objeto es transaccional, o si se invoca explícitamente un método Dispose si el objeto no es transaccional.
True
Si el componente soporta la agrupación de objetos y puede devolverse de forma segura a la agrupación, el método CanBePooled debería devolver True.
False
Si el componente no soporta la agrupación de objetos, o si la instancia actual no puede devolverse a la agrupación, el método CanBePooled debería devolver False.

Uso del método CanBePooled
El siguiente ejemplo muestra cómo crear una agrupación de objetos para el objeto Account con un número mínimo de cinco objetos y un máximo de 50 en un momento dado. El método CanBePooled devuelve True para informar a los servicios de componentes de que el objeto puede devolverse a la agrupación.
Public Class Account
Inherits ServicedComponent
Public Sub Debit(ByVal id As Integer, _
ByVal amount As Double)
...
End Sub
Protected Overrides Function CanBePooled( ) As Boolean
Return True
End Function
End Class


Uso de las cadenas de constructor



Podemos utilizar una cadena de constructor para controlar cómo se inicializan los componentes con servicio. Esto nos permite especificar cualquier información inicial que necesite el objeto, como una cadena de conexión a una base de datos, utilizando la consola de gestión de componentes de los servicios de componentes. Podemos utilizar el atributo ConstructionEnabled para habilitar este proceso en un componente con servicio. Nuestro componente en Visual Basic .NET puede recibir esta información del constructor porque la clase heredada ServicedComponent proporciona el método sobrecargable Construct.
Uso del atributo ConstructionEnabled
Especificamos el atributo ConstructionEnabled a nivel de clase para que pueda pasarse al objeto una cadena de constructor durante la construcción del mismo. Podemos modificar este valor cuando el componente se instala como una aplicación de servicios de componentes utilizando la consola de gestión de Servicios de Componentes.
Uso del método Construct
Sobrecargamos el método Construct de la clase base ServicedComponent para recibir el valor de la cadena enviado al componente durante la construcción.
El siguiente ejemplo muestra cómo habilitar un constructor, sobrecargar el método Construct y pasar una cadena de constructor almacenada en una variable local.


Public Class Account
Inherits ServicedComponent
Private strValue As String
Protected Overrides Sub Construct(ByVal s As String)
'Called after class constructor
strValue = s
End Sub
End Class


Uso de seguridad



objetos predefinidos para configurar y probar las opciones de seguridad.
Opciones de los atributos de seguridad
Podemos establecer opciones de seguridad utilizando atributos en nuestras clases. Los servicios de componentes utilizarán estos atributos cuando configuremos nuestros componentes tal y como se describe en la siguiente tabla:
Atributo
Uso
ApplicationAccessControl
Este atributo a nivel de ensamblado se utiliza para habilitar o deshabilitar explícitamente la comprobación de acceso a nivel de aplicación.
ComponentAccessControl
Este atributo a nivel de componente se utiliza para habilitar o deshabilitar explícitamente la comprobación de acceso a nivel de componente.
SecurityRole
Este atributo a nivel de ensamblado se utiliza para agregar un rol a la aplicación. Este atributo se utiliza a nivel de componente para agregar un rol a la aplicación y enlazarla al componente concreto.

Establecer opciones de seguridad
El siguiente ejemplo muestra cómo establecer el atributo ApplicationAccessControl a nivel de ensamblado, habilitar la seguridad para el componente Account, y crear el rol Manager, que se enlazará al componente Account:

_
Public Class Account
Inherits ServicedComponent
...
End Class
Recuperar información de seguridad
Podemos descubrir información de seguridad sobre el llamador a un componente con servicio utilizando la clase SecurityCallContext. Esta clase proporciona información sobre la cadena de llamadores que llevan a la llamada del método actual. La propiedad estática CurrentCall de la clase SecurityCallContext proporciona acceso a los siguientes métodos y propiedades:
Método o propiedad
Uso
Propiedad DirectCaller
Recupera información sobre el último usuario o aplicación de la cadena de llamadores que directamente invocó un método.
La propiedad devuelve una instancia de la clase SecurityIdentity que podemos utilizar para determinar información sobre la identidad, como AccountName.
Propiedad OriginalCaller
Recupera información sobre el primer usuario o aplicación de la cadena de llamadores que hizo la petición original de la acción requerida.
La propiedad también devuelve una instancia de la clase SecurityIdentity.
Método IsCallerInRole
Verifica si un llamador forma parte de un rol en particular; devuelve un valor Boolean.
Método IsUserInRole
Verifica si el usuario forma parte de un rol en particular; devuelve un valor Boolean.


Uso de la clase SecurityCallContext
El siguiente ejemplo muestra cómo utilizar SecurityCallContext para determinar si la seguridad está habilitada, comprobar si un llamador pertenece al rol Manager y devolver la cadena AccountName desde la propiedad OriginalCaller, que es una instancia SecurityIdentity.
_
Public Class Account
Inherits ServicedComponent
Public Function GetDetails( ) As String
If ContextUtil.IsSecurityEnabled Then
With SecurityCallContext.CurrentCall
If .IsCallerInRole("Manager") Then
Return .OriginalCaller.AccountName
End If
End With
End If
End Function
End Class


Uso de otros servicios de componentes





Hay otros servicios de componentes que podemos utilizar desde componentes de Visual Basic .NET.
Activación Just-in-Time
Cuando se habilita la activación Just-in-time (JIT), un objeto es instanciado automáticamente cuando se invoca un método en un componente con servicio (activación), y desactivado automáticamente cuando el método finaliza (desactivación). Cuando esta opción está habilitada, un objeto no mantiene el estado entre llamadas a métodos, y esto incrementa el rendimiento y la escalabilidad de la aplicación.
Podemos sobrecargar los métodos Activate y Deactivate heredados de la clase ServicedComponent para realizar funcionalidad personalizada durante JIT. Si la agrupación de objetos está habilitada, la activación ocurre cuando un objeto existente se extrae de la agrupación, y la desactivación ocurre cuando el objeto se inserta de nuevo en la agrupación.
JIT se habilita automáticamente si un componente es transaccional, y no puede deshabilitarse. Podemos habilitar o deshabilitar JIT manualmente para componentes no transaccionales utilizando el atributo JustInTimeActivation.
Componentes encolados
Los componentes encolados proporcionan comunicación asíncrona. Esto permite a las aplicaciones cliente enviar peticiones a componentes encolados sin esperar una respuesta. Las peticiones se “graban” y se envían al servidor, donde permanecen encoladas hasta que la aplicación está lista para usar las peticiones. A continuación, estas peticiones se “reproducen” y retornan a la aplicación como si se hubieran enviado desde un cliente normal.
Podemos marcar una aplicación para que utilice colas utilizando el atributo ApplicationQueuing a nivel de ensamblado. Marcamos los componentes individuales con el atributo InterfaceQueuing-


Propiedades compartidas
Podemos utilizar los componentes Shared Property Manager (SPM) para compartir información entre múltiples objetos en el mismo proceso de aplicación. Los componentes SPM se utilizan del mismo modo que los componentes creados en Visual Basic 6.0.
Sincronización
Las aplicaciones distribuidas pueden recibir llamadas simultáneas de múltiples clientes. Gestionar estas peticiones simultáneas implica una lógica de programa compleja para garantizar que se accede a los recursos de forma segura y correcta. Los servicios de componentes proporcionan este servicio automáticamente para componentes que utilizan transacciones. También podemos utilizar el atributo Synchronization para especificar este comportamiento.

Configurar ensamblados para usar los servicios de componentes

Podemos especificar algunos atributos a nivel de ensamblado que proporcionan información cuando nuestro ensamblado se instala como una aplicación de servicios de componentes. La información se almacena en el archivo AssemblyInfo.vb que forma parte de nuestro proyecto en Visual Basic .NET.
Atributo de ensamblado
Uso
ApplicationName
Si utilizamos este atributo para especificar el nombre de la aplicación, una aplicación de servicios de componentes con el mismo nombre cuando nuestro ensamblado sea implantado e instalado.
Description
Utilizamos este atributo para establecer el valor de la descripción de la aplicación de servicios de componentes cuando se implante e instale el ensamblado.
ApplicationActivation
Utilizamos este atributo para especificar si deseamos implementar nuestra aplicación de servicios de componentes como una biblioteca o como una aplicación de servidor.
Los valores aceptables para este atributo son ActivationOption.Server o ActivationOption.Library.
AssemblyKeyFile
Utilizamos este atributo para especificar el nombre y la ubicación del archivo que contiene el par de claves utilizado para generar un nombre compartido.
Establecer los atributos del ensamblado
El siguiente ejemplo muestra una sección de un archivo AssemblyInfo.vb que especifica el nombre de la aplicación, la descripción e información acerca de dónde debería ser activada (es decir, en un servidor o un proceso de biblioteca).

Registro del ensamblado
Podemos registrar nuestro ensamblado con los servicios de componentes de modo manual o automático.
Registro manual
Podemos utilizar la utilidad Regsvcs.exe para registrar manualmente nuestro ensamblado. Esta utilidad utiliza la información que proporcionan los atributos de nuestro ensamblado de modo que la aplicación de servicios de componentes puede crearse con la información predeterminada correcta. La sintaxis básica para utilizar Regsvcs.exe se muestra en el siguiente ejemplo:
Regsvcs.exe myApplication.dll
Registro automático
Si no registramos nuestra aplicación manualmente, el registro se producirá de modo automático cuando una aplicación cliente intente crear una instancia de una clase gestionada que herede de la clase ServicedComponent. Todas las clases ServicedComponent de nuestro ensamblado se registrarán como parte de la aplicación de los Servicios de componentes. Este proceso se denomina Lazy Registration.