Programación Orientada A Objetos en Visual Basic

Programación Orientada a Objetos en Visual Basic

Índice
 Introducción a los objetos en Visual Basic -------------------------------------------------------3
 Descripción de las clases --------------------------------------------------------------------------5
 Clases: como planos para objetos -----------------------------------------------------------6
 Tutorial: Definir clases -----------------------------------------------------------------------8
 Clases y módulos ----------------------------------------------------------------------------11
 Duración de los objetos: cómo se crean y destruyen -------------------------------------12
 Cómo: Implementar el modelo DisposeFinalize (Visual Basic) ---------------------------16
 Utilizar constructores y destructores -------------------------------------------------------18
 Propiedades, campos y métodos de clases-------------------------------------------------24
 Cómo: Agregar campos y propiedades a una clase -----------------------------------24
 Propiedades y procedimientos de propiedad ------------------------------------------26
 Comparación de procedimientos de propiedades y campos Métodos de una clase --28
 Propiedades frente a métodos ----------------------------------------------------------30
 Propiedades predeterminadas Propiedades y métodos sobrecargados. --------------31
 Invalidar propiedades y métodos------------------------------------------------------------36
 Reemplazar modificadores----------------------------------------------------------38
 Crear y utilizar objetos-----------------------------------------------------------------------------38
 Objetos de Visual Basic y otros orígenes -----------------------------------------------------39
 Cómo: Establecer y recuperar propiedades ---------------------------------------------------41
 Cómo: Realizar acciones con métodos---------------------------------------------------------42
 Cómo: Tratar formularios como objetos ------------------------------------------------------44
 Cómo: Obtener acceso a un formulario -------------------------------------------------------45
 Cómo: Utilizar la nueva palabra clave ---------------------------------------------------------46
 Administración de recursos ---------------------------------------------------------------------48
 Cómo: Pasar objetos a procedimientos --------------------------------------------------------49
 Tutorial: Guardar un objeto en Visual Basic ---------------------------------------------------51
 Cómo: Heredar de una clase en Visual Basic---------------------------------------------------56
 Cómo: Leer datos de objetos de un archivo XML en Visual Basic-----------------------------57
 Cómo: Escribir datos de objetos en un archivo XML de Visual Basic--------------------------58
 Colecciones en Visual Basic --------------------------------------------------------------------------59
 Administrar grupos de objetos-------------------------------------------------------------------61
 Administrar objetos propios con colecciones----------------------------------------------------62
 Clase de colección de Visual Basic---------------------------------------------------------------63
 Cómo: Definir colecciones en clases propias----------------------------------------------------66
 Cómo: Definir colecciones con seguridad de tipos----------------------------------------------67
 Cómo: Crear una colección de objetos-----------------------------------------------------------69
 Cómo: Crear una matriz de objetos--------------------------------------------------------------72
 Cómo: Agregar, eliminar y recuperar los elementos de una colección-------------------------73
 Cómo: Recorrer en iteración una colección de Visual Basic-------------------------------------75
 Solucionar problemas de colecciones-------------------------------------------------------------76
 Eventos en Visual Basic---------------------------------------------------------------------------------77
 Eventos y controladores de eventos---------------------------------------------------------------78
 WithEvents y la cláusula Handles------------------------------------------------------------------80
 AddHandler y RemoveHandler---------------------------------------------------------------------81
Pág 1
 Cómo: Agregar eventos a una clase----------------------------------------------------------------82

 Cómo: Crear controladores de eventos en el Editor de código de Visual Basic-------------------83
 Cómo: Provocar un evento (Visual Basic)-----------------------------------------------------------84
 Cómo: Crear un evento y un controlador (Visual Basic)--------------------------------------------84
 Cómo: Escribir controladores de eventos------------------------------------------------------------85
 Cómo: Controlar eventos en Visual Basic------------------------------------------------------------88
 Tutorial: Declarar y provocar eventos----------------------------------------------------------------89
 Tutorial: Controlar eventos----------------------------------------------------------------------------92
 Cómo: Declarar eventos que evitan bloqueos--------------------------------------------------------96
 Cómo: Declarar eventos que evitan que se pierda memoria----------------------------------------97
 Solucionar problemas de controladores de eventos heredados en Visual Basic--------------------99
 Delegados de Visual Basic --------------------------------------------------------------------------------100
 Los delegados y el operador AddressOf--------------------------------------------------------------100
 Cómo: Invocar un método delegado-----------------------------------------------------------------102
 Cómo: Pasar procedimientos a otro procedimiento en Visual Basic--------------------------------103
 Conversión de delegado flexible----------------------------------------------------------------------105
 Interfaces en Visual Basic ---------------------------------------------------------------------------------110
 Información general sobre interfaces-----------------------------------------------------------------111
 Definición de interfaz-----------------------------------------------------------------------------------112
 Palabra clave Implements e instrucción Implements-------------------------------------------------113
 Ejemplos de implementación de interfaces en Visual Basic------------------------------------------114
 Cuándo se deben utilizar interfaces-------------------------------------------------------------------116
 Cómo: Crear e implementar interfaces---------------------------------------------------------------116
 Tutorial: Crear e implementar interfaces-------------------------------------------------------------119
 Herencia en Visual Basic -----------------------------------------------------------------------------------123
 Fundamentos de la herencia---------------------------------------------------------------------------124
 Cómo: Crear clases derivadas-------------------------------------------------------------------------126
 Cuándo utilizar la herencia-----------------------------------------------------------------------------127
 Herencia y .NET Framework----------------------------------------------------------------------------133
 Tutorial: Implementar la herencia mediante objetos COM-------------------------------------------133
 La herencia y la clase de objeto base-----------------------------------------------------------------137
 Cómo funcionan los métodos New y Finalize en una jerarquía de clases---------------------------138
 Polimorfismo--------------------------------------------------------------------------------------------139
 Cómo proporciona Visual Basic polimorfismo----------------------------------------------------140
 Polimorfismo basado en la herencia--------------------------------------------------------------140
 Polimorfismo basado en la interfaz---------------------------------------------------------------141
 Diseñar una jerarquía de herencia--------------------------------------------------------------------143
 Consideraciones de diseño de jerarquías de clases para la extensibilidad---------------------143
 Consideraciones sobre la elección de niveles de acceso para métodos------------------------144
 Cambios en el diseño de la clase base después de la implementación-------------------------145
 Miembros compartidos en Visual Basic --------------------------------------------------------------------146
 Enlace en tiempo de compilación y en tiempo de ejecución ---------------------------------------------148
 Obtener información de clases en tiempo de ejecución----------------------------------------------149
 Determinar el tipo de objeto----------------------------------------------------------------------150
 Llamar a una propiedad o método mediante un nombre de cadena----------------------------152
Pág 2
Programación orientada a objetos en Visual Basic

Actualización: noviembre 2007
Los objetos son el elemento central de la programación en Visual Basic. Los formularios y controles son
objetos. Las bases de datos son objetos. Si ha usado Visual Basic durante algún tiempo, o si ha trabajado
con los ejemplos de la documentación, ya ha programado con objetos, pero hay mucho más en lo que se
refiere a objetos de lo que ha visto hasta aquí.
En los siguientes temas, verá lo fácil que resulta crear objetos propios a partir de las clases que defina, así
como utilizar objetos para simplificar la creación de código y aumentar su reutilización.
En esta sección
Introducción a los objetos en Visual Basic
Proporciona una introducción a los términos y conceptos utilizados en la programación orientada a
objetos.
Descripción de las clases
Proporciona información general sobre las clases y un ejemplo de cómo definir una clase.
Crear y utilizar objetos
Muestra cómo crear y utilizar instancias de clases.
Colecciones en Visual Basic
Proporciona información general sobre las colecciones.
Eventos en Visual Basic
Muestra cómo declarar y utilizar eventos.
Delegados de Visual Basic
Muestra cómo declarar y utilizar delegados.
Interfaces en Visual Basic
Describe qué son las interfaces y cómo pueden utilizarse en las aplicaciones.
Herencia en Visual Basic
Describe cómo definir clases que sirvan como base para otras clases.
Miembros compartidos en Visual Basic
Describe los miembros que se pueden utilizar sin instancias.
Enlace en tiempo de compilación y en tiempo de ejecución
Describe los enlaces, que realiza el compilador cuando se asigna un objeto a una variable de objeto,
y las diferencias entre los objetos con enlaces en tiempo de compilación y en tiempo de ejecución.
Secciones relacionadas
Objetos en Visual Basic
Describe qué son los objetos y cómo se utilizan.
Programar con componentes
Muestra cómo se puede usar Visual Basic para controlar objetos proporcionados por otras
aplicaciones.

Un objeto es una estructura que contiene la información y los métodos que manipulan los datos. Casi todas
las tareas realizadas en Visual Basic están asociadas con objetos. Si no tiene experiencia en programación
orientada a objetos, los siguientes términos y conceptos le ayudarán a comenzar.
Clases y objetos
Pág 3
Las palabras "clase" y "objeto" se usan con tanta frecuencia en la programación orientada a objetos que es
fácil confundir los términos. En general, una class es una representación abstracta de algo, mientras que un
objeto es un ejemplo utilizable de lo que representa la clase. La única excepción a esta regla la constituyen
los miembros de clases compartidas, que pueden utilizarse en instancias de una clase y en variables de
objeto declaradas como tipo de la clase.
Campos, propiedades, métodos y eventos
Las clases se componen de campos, propiedades, métodos y eventos. Los campos y propiedades
representan información que contiene un objeto. Los campos se parecen a las variables ya que se pueden
leer y establecer directamente. Por ejemplo, si tiene un objeto denominado "Car", podría almacenar su color
en un campo denominado "Color".
Las propiedades se recuperan y establecen como los campos, pero se implementan mediante los
procedimientos propiedad Get y Set, que proporcionan más control sobre la forma en que los valores se
establecen o se devuelven. El nivel de direccionamiento indirecto entre el valor que se va a almacenar y los
procedimientos que lo usan ayuda a aislar los datos y permite validar valores antes de asignarlos o
recuperarlos.
Los métodos representan acciones que un objeto puede realizar. Por ejemplo, un objeto "Car" podría tener
los métodos "StartEngine", "Drive" y "Stop". Los métodos se definen agregando procedimientos, ya sean
rutinas o funciones Sub, a la clase.
Los eventos son notificaciones que un objeto recibe de, o transmite a, otros objetos o aplicaciones. Los
eventos permiten a los objetos realizar acciones siempre que se produce un acontecimiento específico. Un
ejemplo de evento para la clase "Car" sería un evento "Check_Engine". Puesto que Microsoft Windows es un
sistema controlado por eventos, éstos pueden proceder de otros objetos, aplicaciones o entradas de usuario
realizadas al hacer clic con el mouse (ratón) o al presionar teclas.
Encapsulación, herencia y polimorfismo
Los campos, propiedades, métodos y eventos son solamente la mitad de la ecuación de la programación
orientada a objetos. Para que la programación orientada a objetos sea auténtica los objetos deben admitir
tres cualidades: encapsulación, herencia y polimorfismo.
La encapsulación significa que un grupo de propiedades, métodos y otros miembros relacionados se tratan
como si de una sola unidad u objeto se tratase. Los objetos pueden controlar cómo se cambian propiedades
o se ejecutan métodos. Por ejemplo, un objeto puede validar valores antes de permitir cambios en la
propiedad. La encapsulación, además, facilita la posibilidad de realizar cambios en la implementación pasado
algún tiempo, mediante una actividad denominada ocultación de datos que permite ocultar los detalles de
implementación de los objetos.
Herencia describe la posibilidad de crear nuevas clases basadas en una clase existente. La nueva clase
hereda todas las propiedades, métodos y eventos de la clase base, y puede personalizarse con propiedades y
métodos adicionales. Por ejemplo, puede crear una nueva clase denominada "Truck" basada en la clase
"Car". La clase "Truck" hereda la propiedad "Color" de la clase "Car" y puede tener propiedades adicionales
como "FourWheelDrive".
Polimorfismo significa que puede tener múltiples clases que se pueden utilizar de forma intercambiable, si
bien cada clase implementa las mismas propiedades o los mismos métodos de maneras diferentes. El
polimorfismo es importante en la programación orientada a objetos puesto que permite usar elementos que
tienen el mismo nombre, independientemente del tipo de objeto que se esté utilizando en ese momento. Por
ejemplo, dada una clase base "Car", el polimorfismo permite al programador definir diferentes métodos
"StartEngine" para cualquier número de clases derivadas. El método "StartEngine" de una clase derivada
denominada "DieselCar" puede ser totalmente diferente del método con el mismo nombre en la clase base.
Otros procedimientos o métodos pueden usar el método "StartEngine" de las clases derivadas de la misma
forma, con independencia del tipo de objeto "Car" que se esté utilizando en ese momento.
Pág 4
Sobrecarga, reemplazo y sombreado

La sobrecarga, el reemplazo y el sombreado son conceptos similares que pueden confundirse fácilmente.
Aunque las tres técnicas permiten crear miembros con el mismo nombre, existen algunas diferencias
importantes.
 Los miembros sobrecargados se utilizan para proporcionar diferentes versiones de una propiedad o
método que tienen el mismo nombre, pero que aceptan un número diferente de parámetros, o
parámetros con diferentes tipos de datos.
 Las propiedades y métodos reemplazados se utilizan para reemplazar una propiedad o método
heredados que no son apropiados en una clase derivada. Los miembros reemplazados deben
aceptar el mismo tipo de datos y número de argumentos. Las clases derivadas heredan los
miembros reemplazados.
 Los miembros sombreados se utilizan para reemplazar localmente un miembro que tiene un ámbito
más amplio. Cualquier tipo puede sombrear cualquier otro tipo. Por ejemplo, puede declarar un
propiedad que sombree un método heredado con el mismo nombre. Los miembros sombreados no
se pueden heredar.
Vea también
Conceptos
Clases: como planos para objetos
Propiedades y métodos sobrecargados
Invalidar propiedades y métodos
Sombrear en Visual Basic
Otros recursos

Las clases son importantes en la programación orientada a objetos puesto que permiten agrupar elementos
relacionados como una unidad, así como controlar su visibilidad y accesibilidad en otros procedimientos. Las
clases también pueden heredar y reutilizar código definido en otras clases.
En esta sección
Proporciona información general de encapsulación, herencia y miembros compartidos.
Tutorial: Definir clases
Proporciona una descripción paso a paso de cómo crear una clase.
Clases y módulos
Explica las diferencias entre clases y módulos estándar.
Duración de los objetos: cómo se crean y destruyen
Explica cómo se crean y destruyen las instancias de clases.
Cómo: Implementar el modelo DisposeFinalize (Visual Basic)
Explica cómo garantizar que se liberan los recursos de un objeto cuando ya no son necesarios.
Utilizar constructores y destructores
Explica cómo se inicializan nuevas instancias de clases y cómo se eliminan recursos cuando ya no
son necesarios.
Propiedades, campos y métodos de clases
Pág 5
Explica los campos, propiedades y métodos que forman una clase.

Describe qué son las interfaces y cómo pueden utilizarse en las aplicaciones.
Describe cómo definir clases que sirvan como base para otras clases.
Guía de programación de Visual Basic

Las clases son representaciones simbólicas de objetos; describen las propiedades, campos, métodos y
eventos que forman objetos de la misma forma que los planos describen los elementos que componen un
edificio. Así como un plano puede utilizarse para crear varios edificios, una única clase puede utilizarse para
crear tantos objetos como sea necesario. Del mismo modo que un plano define qué partes de un edificio son
accesibles a las personas que lo utilizan, las clases también pueden controlar el acceso de los usuarios a los
elementos de objetos a través de la encapsulación.
Clases y objetos
Los términos clase y objeto se utilizan a veces indistintamente, pero en realidad, las clases describen la
estructura de los objetos, mientras que los objetos son instancias de clases que se pueden utilizar. Cada
instancia es una copia exacta pero diferente de su clase. Puesto que un objeto es una instancia de una clase,
la acción de crear un objeto se denomina creación de instancias.
Con la analogía de plano, una clase es un plano y un objeto es un edificio construido a partir de ese plano.
Normalmente, al cambiar los datos en un objeto, no se cambian los datos en ningún otro objeto. (La
excepción la constituyen los miembros compartidos, miembros de clase declarados con el modificador
Shared, que existen de forma independiente de las instancias específicas de una clase).
Encapsulación
La encapsulación es la capacidad de contener y controlar el acceso a un grupo de elementos asociados. Las
clases proporcionan una de las formas más comunes de encapsular elementos. En el ejemplo siguiente, la
clase BankAccount encapsula los métodos, campos y propiedades que describen una cuenta bancaria.
Sin la encapsulación, debería declarar diferentes procedimientos y variables para almacenar y administrar la
información de la cuenta bancaria, y sería difícil trabajar con más de una cuenta bancaria a la vez. La
encapsulación permite utilizar datos y procedimientos de la clase BankAccount como una unidad. Puede
trabajar con varias cuentas bancarias al mismo tiempo sin confusión, puesto que cada cuenta se representa
mediante una instancia única de la clase.
La encapsulación también permite controlar la forma de utilizar los datos y los procedimientos. Se pueden
utilizar modificadores de acceso, como Private o Protected, para evitar que unos procedimientos externos
ejecuten métodos de clase o lean y modifiquen datos en propiedades y campos. Debe declarar detalles
internos de una clase como Private para evitar que se utilicen fuera de su clase; esta técnica se llama
ocultación de datos y es el modo de proteger información del cliente, como un saldo de cuenta por ejemplo.
Una regla básica de la encapsulación es que los datos de clase sólo se deben modificar o recuperar mediante
métodos o procedimientos Property. Al ocultar los detalles de implementación de las clases se evita que
sean utilizados de forma no deseada y hace posible la modificación posterior de tales elementos sin
problemas de compatibilidad. Por ejemplo, en las versiones posteriores de la clase BankAccount se podría
cambiar el tipo de datos del campo AccountBalance sin peligro de interrumpir otras aplicaciones que se
basan en que ese campo tenga un tipo de datos específico.
Pág 6
Herencia
Al igual que para las estructuras de Visual Basic, puede utilizar las clases para definir tipos de datos que
encapsulan un grupo de elementos relacionados. No obstante, a diferencia de las estructuras, las clases de
Visual Basic pueden heredar y extender las características de otras clases. Las clases que sirven de base
para nuevas clases se denominan clases base. Las clases que se derivan de clases base se denominan clases
derivadas. Las clases derivadas heredan todos los campos, propiedades, métodos y eventos de la clase base.
Esto significa que puede desarrollar y depurar una clase una vez y reutilizarla después como base de otras
clases.
En el siguiente ejemplo se define una clase base que representa una cuenta bancaria genérica y una clase
específica que hereda las propiedades de la clase base pero que se personaliza para describir una cuenta
corriente.
Visual Basic
Copiar código
Class BankAccount
Private AccountNumber As String
Private AccountBalance As Decimal
Private HoldOnAccount As Boolean = False
Public Sub PostInterest()
' Add code to calculate the interest for this account.
End Sub
ReadOnly Property Balance() As Decimal
Get
' Return the available balance.
Return AccountBalance
End Get
End Property
End Class
Class CheckingAccount
Inherits BankAccount
Sub ProcessCheck()
' Add code to process a check drawn on this account.
End Sub
End Class
Para obtener más información sobre herencias, consulte Fundamentos de la herencia.

Miembros compartidos
De forma predeterminada, los datos de clase se especifican para cada instancia de la clase, pero en
ocasiones puede ser deseable compartir un solo elemento de datos entre todos los objetos creados a partir
de una clase. En casos como éste, utilice el modificador Shared para hacer que una variable comparta el
mismo valor en todas las instancias de una clase (los miembros Shared a veces se llaman "miembros
estáticos" en otros lenguajes de programación). Los métodos compartidos pueden llamarse directamente
mediante un nombre de clase sin necesidad de crear previamente una instancia de la clase.
Pág 7
Para obtener más información acerca de miembros compartidos, consulte Miembros compartidos en Visual
Basic.
Sombrear
Las clases derivadas pueden utilizar la palabra clave Shadows para declarar un miembro con el mismo
nombre que un miembro heredado. El tipo de datos de los miembros sombreados no es necesario que sea el
mismo que el del miembro que se sombrea. Por ejemplo, una propiedad puede sombrear una variable de
tipo Integer.
Para obtener más información acerca de miembros compartidos, consulte Sombrear en Visual Basic.
Vea también
Conceptos
Estructuras y clases
Fundamentos de la herencia
Referencia
Shadows
Shared (Visual Basic)
Otros recursos
Tutorial: Definir clases

Este tutorial muestra cómo definir clases que se pueden utilizar luego para crear objetos. También muestra
cómo agregar propiedades y métodos a las clases nuevas, e indica cómo inicializar un objeto.
Nota:
Los cuadros de diálogo y los comandos de menú que se ven pueden diferir de los descritos en la
Ayuda, dependiendo de los valores de configuración o de edición activos. Para cambiar su
configuración, haga clic en Importar y exportar configuraciones en el menú Herramientas. Para
obtener más información, vea Valores de configuración de Visual Studio.
Para definir una clase

1. Cree un proyecto haciendo clic en Nuevo proyecto en el menú Archivo. Aparecerá el cuadro de
diálogo Nuevo proyecto.
2. Seleccione Aplicación para Windows de la lista de plantillas del proyecto de Visual Basic para
mostrar el nuevo proyecto.
3. Agregue una clase nueva al proyecto haciendo clic en Agregar clase en el menú Proyecto. Aparecerá
el cuadro de diálogo Agregar nuevo elemento.
4. Seleccione la plantilla Clase.
5. Asigne a la nueva clase el nombre UserNameInfo.vb y, a continuación, haga clic en Agregar para
mostrar el código de la nueva clase.
Visual Basic
Pág 8
Copiar código
Public Class UserNameInfo
End Class
Nota:
Puede utilizar el Editor de código de Visual Basic para agregar una clase al formulario de inicio
escribiendo la palabra clave Class seguida del nombre de la clase nueva. El Editor de código
proporciona la instrucción End Class correspondiente.
6. Defina un campo privado para la clase; para ello, agregue el siguiente código entre las instrucciones
Class y End Class:
Visual Basic
Copiar código
Private userNameValue As String
Declarar el campo como Private quiere decir que sólo se puede utilizar dentro de la clase. Se
pueden utilizar modificadores de acceso más amplio, por ejemplo Public, para hacer que los
campos estén disponibles desde fuera de la clase. Para obtener más información, vea Niveles de
acceso en Visual Basic.
7. Defina una propiedad para la clase agregando el código siguiente:
Visual Basic
Copiar código
Public Property UserName() As String
Get
' Gets the property value.
Return userNameValue
End Get
Set(ByVal Value As String)
' Sets the property value.
userNameValue = Value
End Set
End Property
8. Defina un método para la clase agregando el código siguiente:
Visual Basic
Copiar código
Public Sub Capitalize()
Pág 9
' Capitalize the value of the property.

userNameValue = UCase(userNameValue)
End Sub
9. Defina un constructor parametrizado para la clase nueva agregando un procedimiento denominado

Sub New:
Visual Basic
Copiar código
Public Sub New(ByVal UserName As String)
' Set the property value.
Me.UserName = UserName
End Sub
Cuando se crea un objeto basado en esta clase, se llama al constructor Sub New automáticamente.
Este constructor establece el valor del campo que contiene el nombre de usuario.
Para crear un botón que pruebe la clase

1. Cambie el formulario de inicio al modo de diseño haciendo clic con el botón secundario del mouse
en su nombre desde el Explorador de soluciones y, a continuación, haga clic en Diseñador de vistas.
De forma predeterminada, el nombre que se asigna al formulario de inicio para los proyectos de
aplicación para Windows es Form1.vb. Aparecerá el formulario principal.
2. Agregue un botón al formulario principal y haga doble clic en él para mostrar el código del
controlador de eventos Button1_Click. Agregue el código siguiente para llamar al procedimiento
de prueba:
Visual Basic
Copiar código
' Create an instance of the class.
Dim user As New UserNameInfo("Moore, Bobby")
' Capitalize the value of the property.
user.Capitalize()
' Display the value of the property.
MsgBox("The original UserName is: " & user.UserName)
' Change the value of the property.
user.UserName = "Worden, Joe"
' Redisplay the value of the property.
MsgBox("The new UserName is: " & user.UserName)
Pág 10
Para ejecutar la aplicación

1. Presione F5para ejecutar la aplicación. Llame al procedimiento de prueba haciendo clic en el botón
del formulario. Muestra un mensaje que indica que el UserName original es "MOORE, BOBBY",
porque el procedimiento llamó al método Capitalize del objeto.
2. Haga clic en Aceptar para descartar el cuadro de mensaje. El procedimiento Button1 Click
cambia el valor de la propiedad UserName y muestra un mensaje que indica que el nuevo valor de
UserName es "Worden, Joe."
Vea también
Tareas
Cómo: Agregar eventos a una clase
Conceptos
Clases y módulos
Referencia
Instrucción Imports (Tipo y espacio de nombres de .NET)
Otros recursos
Clases y módulos
Tanto las clases como los módulos son tipos de referencia que encapsulan los elementos definidos en ellos,
pero difieren en la forma en que se realiza el acceso a los elementos desde otros procedimientos.
Diferencias entre clases y módulos
La diferencia principal entre clases y módulos consiste en que pueden crearse instancias de clases como
objetos pero no de módulos. Como sólo existe una copia de los datos de un módulo estándar, cuando una
parte del programa cambia una variable pública en un módulo estándar, cualquier otra parte del programa
obtendrá el mismo valor si lee luego esa variable. En comparación, los datos de objeto existen
individualmente para cada objeto con instancias. Otra distinción es que, a diferencia de los módulos
estándar, las clases pueden implementar interfaces.
Nota:
Cuando el modificador Shared se aplica a un miembro de clase, está asociado con la propia clase
en lugar de con una instancia determinada de la clase. Se tiene acceso directo al miembro
mediante el nombre de clase, de la misma manera que se tiene acceso a los miembros de
módulos. Para obtener más información acerca de miembros compartidos, consulte Miembros
compartidos en Visual Basic.
Las clases y los módulos también emplean ámbitos diferentes para sus miembros. Los miembros definidos
dentro de una clase tienen el ámbito de una instancia específica de la clase y sólo existen mientras dure el
objeto. Para tener acceso a los miembros de clases desde el exterior de una clase, debe utilizar los nombres
completos con el formato Objeto.Miembro.
Por otro lado, los miembros declarados dentro de un módulo son de manera predeterminada accesibles
públicamente y se puede obtener acceso a ellos mediante cualquier código que tenga acceso al módulo. Esto
significa que las variables en un módulo estándar son de hecho variables globales porque son visibles desde
cualquier parte del proyecto y existen durante toda la vida útil del programa.
Vea también
Pág 11
Conceptos
Referencia
Otros recursos

Una instancia de una clase (un objeto) se crea mediante la palabra clave New. A menudo hay que realizar
tareas de inicialización en los objetos nuevos antes de utilizarlos. Entre las tareas de inicialización comunes
se incluyen abrir archivos, conectar con bases de datos y leer valores de claves del Registro. Visual Basic
controla la inicialización de objetos nuevos mediante unos procedimientos denominados constructores
(métodos especiales que proporcionan control sobre la inicialización).
Common Language Runtime (CLR) libera un objeto cuando éste ha salido del ámbito. Visual Basic controla la
liberación de recursos del sistema mediante unos procedimientos denominados destructores. Juntos, los
constructores y destructores permiten la creación de bibliotecas de clases robustas y predecibles.
Sub New y Sub Finalize
Los procedimientos Sub New y Sub Finalize de Visual Basic inicializan y destruyen objetos; reemplazan a
los métodos Class_Initialize y Class_Terminate que se utilizaban en Visual Basic 6.0 y versiones
anteriores. A diferencia de Class_Initialize, el constructor Sub New sólo se puede ejecutar una vez cuando
se crea una clase. Sólo se le puede llamar explícitamente desde la primera línea de código de otro
constructor en la misma clase o en una clase derivada. Además, el código del método Sub New siempre se
ejecuta antes de cualquier otro código en una clase. Visual Basic 2005 y las versiones posteriores crean
implícitamente en tiempo de ejecución un constructor Sub New si no define explícitamente un
procedimiento Sub New para una clase.
Antes de liberar objetos, CLR llama automáticamente al método Finalize para los objetos que definen un
procedimiento Sub Finalize. El método Finalize puede contener código que es necesario ejecutar
inmediatamente antes de destruir un objeto, por ejemplo el código para cerrar archivos y guardar
información de estado. Puesto que se produce una ligera disminución del rendimiento al ejecutar Sub
Finalize, este método sólo debe definirse cuando sea necesario liberar objetos explícitamente.
Nota:
El recolector de elementos no utilizados de CLR no se deshace de los objetos no administrados (ni

puede eliminarlos), que son aquellos que el sistema operativo ejecuta directamente, fuera del
entorno de CLR. Esto se debe a que hay que deshacerse de los objetos no administrados
diferentes de maneras distintas. Esa información no está asociada directamente al objeto no
administrado; se debe buscar en la documentación del objeto. Una clase que utiliza objetos no
administrados debe deshacerse de ellos en su método Finalize.
El destructor Finalize es un método protegido al que sólo se puede llamar desde la clase a la que pertenece
o desde clases derivadas. El sistema llama automáticamente a Finalize cuando se destruye un objeto, por lo
que no se debe llamar explícitamente a Finalize desde fuera de una implementación de su clase derivada.
A diferencia de Class_Terminate, que se ejecuta en cuanto un objeto se establece en Nothing,
normalmente hay un retardo entre el momento en que un objeto pierde el ámbito y el momento en que
Visual Basic llama al destructor Finalize. Visual Basic 2005 y versiones posteriores proporcionan un segundo
Pág 12
tipo de destructor, Dispose, al que se puede llamar explícitamente en cualquier momento para liberar
recursos de forma inmediata.
Nota:
Un destructor Finalize no debería producir excepciones porque la aplicación no puede controlarlas

y pueden hacer que la aplicación finalice.
Interfaz IDisposable
A menudo, las instancias de clase controlan los recursos que no administra CLR, como identificadores de
Windows y conexiones de bases de datos. Estos recursos se deben desechar en el método Finalize de la
clase, a fin de liberarlos cuando el recolector de elementos no utilizados destruya el objeto. Sin embargo, el
recolector de elementos no utilizados sólo destruye los objetos cuando CLR requiere más memoria libre. Esto
significa que los recursos pueden no liberarse hasta mucho después de que el objeto salga del ámbito.
Para complementar la recolección de elementos no utilizados, las clases pueden proporcionar un mecanismo
que administra activamente los recursos del sistema si implementan la interfaz IDisposable. IDisposable
tiene un método, Dispose, al que los clientes deben llamar cuando terminan de utilizar un objeto. Se puede
utilizar el método Dispose para liberar recursos inmediatamente y realizar tareas como cerrar archivos y
conexiones de bases de datos. A diferencia del destructor Finalize, el método Dispose no se llama
automáticamente. Los clientes de una clase deben llamar explícitamente a Dispose cuando se desea liberar
recursos inmediatamente.
Implementar IDisposable
Una clase que implementa la interfaz IDisposable debería incluir estas secciones de código:
 Un campo para mantener el seguimiento de si se ha desechado el objeto:
Copiar código
Protected disposed As Boolean = False
 Una sobrecarga de Dispose que libera los recursos de la clase. Los métodos Dispose y Finalize de
la clase base deben llamar a este método:
Copiar código
Protected Overridable Sub Dispose(ByVal disposing As Boolean)
If Not Me.disposed Then
If disposing Then
' Insert code to free managed resources.
End If
' Insert code to free unmanaged resources.
End If
Me.disposed = True
End Sub
 Una implementación de Dispose que contiene sólo el código siguiente:
Copiar código
Public Sub Dispose() Implements IDisposable.Dispose
Dispose(True)
GC.SuppressFinalize(Me)
Pág 13
End Sub
 Un reemplazo del método Finalize que contiene sólo el código siguiente:
Copiar código
Protected Overrides Sub Finalize()
Dispose(False)
MyBase.Finalize()
End Sub
Derivar de una clase que implementa IDisposable
Una clase derivada de una clase base que implementa la interfaz IDisposable no necesita reemplazar
ninguno de los métodos base a menos que utilice recursos adicionales que se deban desechar. En esa
situación, la clase derivada debería reemplazar el método Dispose(disposing) de la clase base para
desechar los recursos de la clase derivada. Este reemplazo debe llamar al método Dispose(disposing) de
la clase base.
Copiar código
Protected Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
End If
End If
MyBase.Dispose(disposing)
End Sub
Una clase derivada no debería reemplazar los métodos Dispose y Finalize de la clase base. Cuando se llama
a estos métodos desde una instancia de una clase derivada, la implementación de estos métodos en la clase
base llama al reemplazo del método Dispose(disposing) en la clase derivada.
Visualización
El diagrama siguiente muestra qué métodos se heredan y qué métodos se reemplazan en la clase derivada.
Cuando se sigue el modelo DisposeFinalize, los recursos de la clase derivada y de la clase base se
desechan correctamente. El diagrama siguiente muestra a qué métodos se llaman cuando las clases se
desechan y finalizan.
Pág 14
Recolección de elementos no utilizados y el destructor Finalize

.NET Framework utiliza el sistema de recolección de elementos no utilizados por seguimiento de referencias
para liberar periódicamente los recursos no utilizados. Visual Basic 6.0 y las versiones anteriores utilizaban
un sistema diferente denominado recuento de referencias para administrar los recursos. Aunque ambos
sistemas realizan la misma función automáticamente, existen algunas diferencias importantes.
CLR destruye periódicamente objetos cuando el sistema determina que ya no son necesarios. Los objetos se
liberan con mayor rapidez cuando los recursos del sistema son escasos y con menor frecuencia en caso
contrario. El retraso que se produce entre el momento en que un objeto pierde su ámbito y el momento en
que CLR lo libera significa que, a diferencia de lo que ocurre con los objetos en Visual Basic 6.0 y versiones
anteriores, no se puede determinar exactamente cuándo se destruirá el objeto. En tal situación, se dice que
los objetos tienen duración no determinista. En la mayoría de los casos, la duración no determinista no
cambia la forma de escribir las aplicaciones, siempre que se recuerde que el destructor Finalize puede no
ejecutarse inmediatamente cuando un objeto pierde su ámbito.
Otra diferencia entre los sistemas de recolección de elementos no utilizados tiene que ver con el uso de
Nothing. Para aprovechar el recuento de referencias de Visual Basic 6.0 y versiones anteriores, los
programadores a veces asignaban Nothing a variables de objeto para liberar las referencias que esas
variables almacenaban. Si la variable almacenaba la última referencia al objeto, los recursos del objeto se
liberaban inmediatamente. En las versiones posteriores de Visual Basic, aunque puede haber casos en los
que este procedimiento sea aún útil, su realización nunca ocasionará que el objeto de referencia libere sus
recursos inmediatamente. Para liberar inmediatamente los recursos, utilice el método Dispose del objeto, si
está disponible. La única vez en que debe establecerse una variable en Nothing es cuando su duración sea
larga con relación al tiempo que necesita el recolector de elementos no utilizados para detectar objetos
huérfanos.
Vea también
Tareas
Conceptos
Inicialización y finalización de componentes
Métodos de finalización y destructores
Referencia
New (Visual Basic)
Dispose
Nothing (Visual Basic)
Otros recursos
Cambios en el lenguaje para usuarios de Visual Basic 6.0
Pág 15

El modelo DisposeFinalize garantiza que se liberan los recursos cuando ya no se necesita el objeto.
Ejemplo
La clase ResourceClass del ejemplo siguiente utiliza recursos administrados y no administrados y, a
continuación, utiliza el modelo DisposeFinalize para desecharlos correctamente. Los recursos y sus
funciones son:
 La implementación del método Dispose, que permite a los usuarios de la clase desechar las
instancias de clase. Este método llama a Dispose(True) para desechar los recursos del objeto y, a
continuación, llama a SuppressFinalize para evitar que el código de finalización se ejecute una
segunda vez.
 El reemplazo del método base Finalize, que permite al recolector de elementos no utilizados de
Common Language Runtime (CLR) desechar las instancias de clase. Este método llama a
Dispose(False) para desechar los recursos del objeto. Observe que si se llama a Dispose
previamente para el objeto, su llamada a SuppressFinalize evitaría que el recolector de elementos
no utilizados llamase al método Finalize.
 La sobrecarga del método Dispose, que lleva a cabo el trabajo de eliminación. Toma un parámetro
de tipo Boolean, disposing, que indica si el código ha iniciado la eliminación del objeto. Cuando
desecha un objeto, también se deben desechar todos sus recursos. Cuando el recolector de
elementos no utilizados de CLR elimina un objeto, sólo deben eliminarse los recursos no
administrados; el recolector elimina automáticamente los recursos administrados cuando resulta
necesario.
Para obtener más información, vea Duración de los objetos: cómo se crean y destruyen.
Visual Basic
Copiar código
Public Class ResourceClass
Implements IDisposable
Private managedResource As System.ComponentModel.Component

Private unmanagedResource As IntPtr
Public Sub New()

' Insert appropriate constructor code here.
End Sub
Protected Overridable Overloads Sub Dispose( _

ByVal disposing As Boolean)
If disposing Then
managedResource.Dispose()
End If
' Add code here to release the unmanaged resource.
unmanagedResource = IntPtr.Zero
Pág 16
' Note that this is not thread safe.

End If
Me.disposed = True
End Sub
Public Sub AnyOtherMethods()

If Me.disposed Then
Throw New ObjectDisposedException(Me.GetType().ToString,
_
"This object has been disposed.")
End If
End Sub
#Region " IDisposable Support "

' Do not change or add Overridable to these methods.
' Put cleanup code in Dispose(ByVal disposing As Boolean).
Public Overloads Sub Dispose() Implements IDisposable.Dispose
Dispose(True)
End Sub
Dispose(False)
MyBase.Finalize()
End Sub
#End Region
End Class
Este ejemplo de código también está disponible como fragmento de código de IntelliSense. En el selector de
fragmentos de código, se encuentra en Lenguaje Visual Basic. Para obtener más información, vea Cómo:
Insertar fragmentos de código en el código (Visual Basic).
Compilar el código
Para este ejemplo se necesita:
 Obtener acceso a los miembros de los espacios de nombres System y System.ComponentModel.
Agregar una instrucción Imports si no se incluyen nombres de miembro completos en el código.
Para obtener más información, vea Instrucción Imports (Tipo y espacio de nombres de .NET).
Estos cambios se deben realizar en el código:
 Reemplace ResourceClass con el nombre de la clase que implementa IDisposable.
 Utilice la comprobación de AnyOtherMethods en cualquier método que utilice recursos que se
pueden haber desechado.
 Reemplace la declaración managedResource con declaraciones de cualquier objeto administrado en
su clase que deba ser desechado. Si una clase implementa IDisposable o tiene un método Close,
probablemente necesita ser desechado. En el método Dispose, cierre o deseche estos objetos.
Pág 17
 Reemplace la declaración unManagedResource con declaraciones de objetos no administrados en

su clase que deban ser desechados. El método para desechar estos objetos depende de cómo se
define el objeto. Para obtener detalles, consulte la documentación sobre el objeto.
Programación eficaz
Cuando se ha llamado al método Dispose, los objetos contenidos en su colección no serán válidos. Debería
probar el campo disposed antes de realizar cualquier operación en su objeto. Para obtener un ejemplo, vea
el método AnyOtherMethods en el ejemplo de código.
Vea también
Conceptos
Implementar un método Dispose
Referencia
IDisposable
Otros recursos
Recolección de elementos no utilizados

Los constructores y destructores controlan la creación y destrucción de objetos.
Constructores
Para crear un constructor para una clase, cree un procedimiento denominado Sub New en cualquier parte
de la definición de clase. Para crear un constructor parametrizado, especifique los nombres y los tipos de
datos de los argumentos de Sub New tal como lo haría en cualquier otro procedimiento, como en el código
siguiente:
Visual Basic
Copiar código
Sub New(ByVal s As String)
Con frecuencia, los constructores están sobrecargados, como en el código siguiente:

Visual Basic
Copiar código
Sub New(ByVal s As String, i As Integer)
Cuando se define una clase derivada de otra, la primera línea del constructor debe ser una llamada al
constructor de la clase base, a no ser que ésta tenga un constructor accesible que no requiera parámetros.
Por ejemplo, para llamar a la clase base que contiene el constructor anterior, sería MyBase.New(s). En caso
contrario, MyBase.New es opcional y el tiempo de ejecución de Visual Basic la llama implícitamente.
Después de escribir el código para llamar al constructor del objeto primario, puede agregar cualquier código
de inicialización adicional en el procedimiento Sub New. Sub New puede aceptar argumentos cuando se
realiza la llamada como a un constructor con parámetros. Estos parámetros se pasan desde el procedimiento
que llama al constructor; por ejemplo, Dim AnObject As New ThisClass(X).
Destructores
El código siguiente muestra cómo utilizar Dispose y Finalize para liberar los recursos de una clase base.
Nota:
Pág 18
Debería seguir las instrucciones para implementar IDisposable incluidas en Duración de los
objetos: cómo se crean y destruyen.
Visual Basic
Copiar código
' Design pattern for a base class.
Public Class Base
' Keep track of when the object is disposed.

' This method disposes the base object's resources.

Protected Overridable Sub Dispose(ByVal disposing As Boolean)
If disposing Then
End If
End If
Me.disposed = True
End Sub
#Region " IDisposable Support "

' Do not change or add Overridable to these methods.
' Put cleanup code in Dispose(ByVal disposing As Boolean).
Public Sub Dispose() Implements IDisposable.Dispose
Dispose(True)
End Sub
Dispose(False)
MyBase.Finalize()
End Sub
#End Region
End Class
El código siguiente muestra cómo utilizar Dispose y Finalize para liberar los recursos de una clase
derivada.
Visual Basic
Copiar código
' Design pattern for a derived class.
Pág 19
Public Class Derived

Inherits Base
' This method disposes the derived object's resources.

Protected Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
End If
End If
MyBase.Dispose(disposing)
End Sub
' The derived class does not have a Finalize method

' or a Dispose method with parameters because it inherits
' them from the base class.
End Class
El código siguiente muestra un modelo de diseño común para el destructor Dispose, utilizando un bloque
Using y un bloque Try...Finally equivalente.
Visual Basic
Copiar código
Sub DemonstrateUsing()
Using d As New Derived
' Code to use the Derived object goes here.
End Using
End Sub
Sub DemonstrateTry()
Dim d As Derived = Nothing
Try
d = New Derived
' Code to use the Derived object goes here.
Finally
' Call the Dispose method when done, even if there is an
exception.
If Not d Is Nothing Then
d.Dispose()
End If
End Try
Pág 20
End Sub
En el siguiente ejemplo se crea un objeto mediante un constructor con parámetros y se llama a los
destructores cuando el objeto deja de ser necesario.
Nota:
Aunque este ejemplo usa Collect para mostrar a qué métodos llama el recolector de elementos no
utilizados para eliminar métodos, en general es más conveniente dejar que Common Language
Runtime (CLR) administre la recolección de elementos no utilizados.
Visual Basic
Copiar código
Sub TestConstructorsAndDestructors()
' Demonstrate how the Using statement calls the Dispose method.
Using AnObject As New ThisClass(6)
' Place statements here that use the object.
MsgBox("The value of ThisProperty after being initialized " & _
" by the constructor is " & AnObject.ThisProperty & ".")
End Using
' Demonstrate how the garbage collector calls the Finalize method.
Dim AnObject2 As New ThisClass(6)
AnObject2 = Nothing
GC.Collect()
End Sub
Public Class BaseClass

Sub New()
MsgBox("BaseClass is initializing with Sub New.")
End Sub

MsgBox("BaseClass is shutting down with Sub Finalize.")
' Place final cleanup tasks here.
MyBase.Finalize()
End Sub
End Class
Public Class ThisClass

Inherits BaseClass
Pág 21
Sub New(ByVal SomeValue As Integer)

' Call MyBase.New if this is a derived class.
MyBase.New()
MsgBox("ThisClass is initializing with Sub New.")
' Place initialization statements here.
ThisPropertyValue = SomeValue
End Sub
Private ThisPropertyValue As Integer

Property ThisProperty() As Integer
Get
CheckIfDisposed()
ThisProperty = ThisPropertyValue
End Get
Set(ByVal Value As Integer)
CheckIfDisposed()
ThisPropertyValue = Value
End Set
End Property

MsgBox("ThisClass is shutting down with Sub Finalize.")
Dispose(False)
End Sub
' Do not add Overridable to this method.

Public Overloads Sub Dispose() Implements IDisposable.Dispose
MsgBox("ThisClass is shutting down with Sub Dispose.")
Dispose(True)
End Sub
Private disposed As Boolean = False

Public Sub CheckIfDisposed()
If Me.disposed Then
Throw New ObjectDisposedException(Me.GetType().ToString, _
"This object has been disposed.")
End If
End Sub
Pág 22
Protected Overridable Overloads Sub Dispose( _

ByVal disposing As Boolean)
MsgBox("ThisClass is shutting down with the Sub Dispose
overload.")
' Place final cleanup tasks here.
If disposing Then
' Dispose of any managed resources.
End If
' Dispose of any unmanaged resource.
' Call MyBase.Finalize if this is a derived class,

' and the base class does not implement Dispose.
MyBase.Finalize()
End If
Me.disposed = True
End Sub
End Class
Cuando ejecute este ejemplo, la clase ThisClass llama al constructor Sub New de la clase BaseClass.
Una vez que finaliza el constructor de la clase base, la clase ThisClass ejecuta el resto de instrucciones de
Sub New que inicializan un valor para la propiedad ThisProperty.
Cuando la clase ya no es necesaria, se llama al destructor Dispose en ThisClass.
Este ejemplo muestra lo siguiente:
BaseClass is initializing with Sub New.
ThisClass is initializing with Sub New.
The value of ThisProperty after being initialized by the constructor is 6.
ThisClass is shutting down with Sub Dispose.
ThisClass is shutting down with the Sub Dispose overload.
BaseClass is shutting down with Sub Finalize.
BaseClass is initializing with Sub New.
ThisClass is initializing with Sub New.
ThisClass is shutting down with Sub Finalize.
ThisClass is shutting down with the Sub Dispose overload.
BaseClass is shutting down with Sub Finalize.
Vea también
Conceptos
Métodos de finalización y destructores
Cómo funcionan los métodos New y Finalize en una jerarquía de clases
Referencia
Dispose
Pág 23

En general, los campos y las propiedades representan información sobre un objeto, mientras que los
métodos representan acciones que un objeto puede realizar.
Los temas siguientes describen los mecanismos para agregar propiedades, campos y métodos a las clases, y
abordan cuestiones relacionadas con estos elementos.
En esta sección
Cómo: Agregar campos y propiedades a una clase
Proporciona información acerca de la declaración de campos y propiedades.
Propiedades y procedimientos de propiedad
Explica cómo funcionan los procedimientos Property y cómo se implementan los tipos de propiedad
comunes.
Comparación de procedimientos de propiedades y campos
Ayuda a decidir cuándo deben utilizarse campos para almacenar datos de una clase y cuándo el uso
de propiedades es una opción mejor.
Métodos de una clase
Describe los procedimientos públicos que se agregan a la clase.
Propiedades frente a métodos
Ayuda a decidir si la funcionalidad que se desea se implementa mejor como propiedad o como
método.
Propiedades predeterminadas
Describe las propiedades que se utilizan cuando no se define ninguna propiedad específica.
Describe cómo se definen varias propiedades o métodos que tienen el mismo nombre, pero que
funcionan con tipos de datos diferentes.
Describe la redefinición de una propiedad o método heredados.
Muestra cómo declarar y utilizar eventos.
Muestra cómo declarar y utilizar delegados.
Administrar objetos propios con colecciones
Proporciona información sobre el uso de colecciones para almacenar y recuperar objetos.

Se pueden utilizar tanto campos como propiedades para almacenar información en un objeto. Aunque los
campos y las propiedades son muy difíciles de distinguir desde una perspectiva de aplicación de cliente, se
declaran de forma diferente en una clase. Mientras que los campos son simplemente variables públicas que
una clase expone, las propiedades utilizan procedimientos Property para controlar cómo se establecen y
devuelven valores.
Pág 24
Para agregar un campo a una clase

 Declare una variable pública en la definición de clase, como en el código siguiente:
Visual Basic
Copiar código
Class ThisClass
Public ThisField As String
End Class
Para agregar una propiedad a una clase

1. Declare una variable local en la clase para almacenar el valor de la propiedad. Este paso es
necesario puesto que las propiedades no asignan almacenamiento por sí mismas. A fin de proteger
sus valores contra la modificación directa, las variables que se utilizan para almacenar valores de
propiedad deben declarase como Private.
2. Escriba modificadores antes de las declaraciones de propiedad, como Public y Shared, según
corresponda. Utilice la palabra clave Property para declarar el nombre de la propiedad y declare el
tipo de datos que la propiedad almacena y devuelve.
3. Defina los procedimientos de propiedad Get y Set dentro de la definición de propiedad. Los
procedimientos de propiedad Get se utilizan para devolver el valor de una propiedad y son
aproximadamente equivalentes a las funciones de sintaxis. No aceptan ningún argumento y se
pueden utilizar para devolver el valor de variables local privadas declaradas dentro de la clase
utilizada para almacenar el valor de la propiedad. Los procedimientos de propiedad Set se utilizan
para establecer el valor de una propiedad; tienen un parámetro, llamado normalmente Value, con
el mismo tipo de datos que la propiedad en sí. Cada vez que se cambia el valor de la propiedad, se
pasa Value al procedimiento de propiedad Set, donde se puede validar y almacenar en una
variable local.
4. Finalice los procedimientos de propiedad Get y Set con las instrucciones End Get y End Set
correspondientes.
5. Finalice el bloque de propiedad con una instrucción End Property.
Nota:
Si está trabajando dentro del entorno de desarrollo integrado (IDE) de Visual Studio, puede
dirigirlo para crear procedimientos de propiedad Get y Set vacíos. Escriba
Property NombreProp As TipoDeDatos (donde NombreProp es el nombre de la propiedad y
TipoDeDatos es un tipo de datos específico, por ejemplo Integer), y los procedimientos de
propiedad aparecen en el Editor de código.
6. En el siguiente ejemplo se declara una propiedad en una clase:

7. Visual Basic
8. Copiar código
9. Class ThisClass
10. Private m_PropVal As String
11. Public Property One() As String
12. Get
Pág 25
13. ' Return the value stored in the local variable.

14. Return m_PropVal
15. End Get
16. Set(ByVal Value As String)
17. ' Store the value in a local variable.
18. m_PropVal = Value
19. End Set
20. End Property
21. End Class
22.
23. Cuando se crea una instancia de ThisClass y se establece el valor de la propiedad One, se llama al
procedimiento de propiedad Set y se pasa el valor en el parámetro Value, que se almacena en una
variable local denominada m_PropVal. Cuando se recupera el valor de esta propiedad, se llama al
procedimiento de propiedad Get como función y devuelve el valor almacenado en la variable local
m_PropVal.
Vea también
Tareas
Conceptos
Referencia
Property (Instrucción)
Public (Visual Basic)

Se pueden utilizar tanto propiedades como campos para almacenar información en un objeto. Mientras que
los campos son simplemente variables públicas, las propiedades utilizan procedimientos de propiedad para
controlar cómo se establecen y devuelven valores. Los procedimientos de propiedad son bloques de código
declarados dentro de las definiciones de propiedad que puede ejecutar código cuando se establece o
recupera el valor de una propiedad.
Visual Basic tiene dos tipos de procedimientos de propiedad: los procedimientos de propiedad Get para
recuperar un valor de una propiedad y los procedimientos de propiedad Set para asignar un valor a una
propiedad. Por ejemplo, una propiedad que almacena el saldo de una cuenta bancaria podría utilizar código
en un procedimiento de propiedad Get para notificar el interés y comprobar comisiones por servicios antes
de devolver el saldo disponible. Puede utilizar luego el procedimiento de propiedad Set para validar el
balance y evitar que se actualice incorrectamente. Es decir, los procedimientos de propiedad permiten a un
objeto proteger y validar sus propios datos.
En el siguiente fragmento de código se compara el modo en el que los campos y propiedades validan los
valores.
Visual Basic
Copiar código
Protected Sub TestFieldsAndProperties()
Pág 26
' Assume, for this example, that the only valid values for
' the field and property are numbers less than 10.
Dim NewClass As New ThisClass
' Test data validation.
' Works because there is no data validation.

NewClass.ThisField = 36
' Will print 36.
MsgBox("ThisField = " & NewClass.ThisField)
' The attempt to set the field to a value greater than 10 will
silently fail.
NewClass.ThisProperty = 36
' The next statement will print the old value of 0 instead.
MsgBox("ThisProperty = " & NewClass.ThisProperty)
End Sub
Public Class ThisClass

' Declare a field.
Public ThisField As Integer
' Field used for Property Set operations.
Private thisPropertyValue As Integer = 0
' Declare a property.
Public Property ThisProperty() As Integer
Get
Return thisPropertyValue
End Get
Set(ByVal Value As Integer)
' Only allow Set operation for values less than 10.
If Value < 10 Then thisPropertyValue = Value
End Set
End Property
End Class
El procedimiento TestFieldsAndProperties crea una instancia de la clase, y establece y recupera los

valores de los campos y propiedades. En este ejemplo se asume que los únicos valores válidos son números
menores de 10. Dado que no hay forma de validar los valores asignados a los campos, es posible establecer
en el campo el valor 36. No obstante, la propiedad solamente realiza asignaciones para números menores de
10, de modo que el intento de establecer 36 en el campo no se tiene en cuenta.
Propiedades de sólo lectura y escritura
Pág 27
La mayoría de las propiedades tienen procedimientos de propiedad Get y Set que puede utilizar para leer y
modificar el valor que almacenan. No obstante, puede utilizar los modificadores ReadOnly y WriteOnly
para restringir la modificación o la lectura de las propiedades.
Las propiedades de sólo lectura no pueden tener procedimientos de propiedad Set; estas propiedades son
útiles para elementos que desea exponer, pero cuya modificación no desea permitir. Por ejemplo, podría
utilizar una propiedad de sólo lectura para proporcionar la velocidad del procesador de un equipo.
Las propiedades de sólo escritura no pueden tener procedimientos de propiedad Get y son útiles para
configurar objetos con datos que no deben o no se pueden almacenar en el objeto. Por ejemplo, se puede
utilizar una propiedad de sólo escritura para tomar una contraseña y cambiar el estado del objeto sin
almacenar la contraseña.
Nota:
Las versiones anteriores de Visual Basic admiten procedimientos de propiedad Let que se utilizan
al asignar objetos a las propiedades. Visual Basic elimina la necesidad de procedimientos de
propiedad Let porque la asignación de objetos se controla como cualquier otro tipo de asignación.
Vea también
Conceptos
Procedimientos de propiedad
Referencia
Get (Instrucción)
Instrucción Set (Visual Basic)
ReadOnly (Visual Basic)
WriteOnly

Las propiedades y los campos ambos almacenan y recuperan información en un objeto. Dada su similitud,
resulta difícil determinar cuál es la mejor opción de programación en casos concretos.
Utilice procedimientos de propiedad cuando:
 Necesite controlar cuándo y cómo se establece o recupera un valor.
 La propiedad tenga un conjunto de valores bien definidos que no necesiten validación.
 El establecimiento del valor genera algún cambio perceptible en el estado del objeto, como una
propiedad IsVisible.
 El establecimiento de la propiedad ocasione cambios en otras variables internas o en los valores de
otras propiedades.
 Deban ejecutarse un conjunto de pasos antes de poder establecer o recuperar la propiedad.
Utilice campos cuando:
 El valor sea de un tipo de autovalidación. Por ejemplo, si un valor distinto de True o False se
asigna a una variable Boolean, se produce un error o una conversión de datos automática.
 Sea válido cualquier valor del intervalo admitido por el tipo de datos. Esto es verdadero en muchas
propiedades de tipo Single o Double.
 La propiedad sea un tipo de datos String y no existan restricciones en cuanto al tamaño o al valor
de la cadena.
Vea también
Pág 28
Conceptos
Clases y módulos
Tipos de datos en Visual Basic

Los métodos de una clase son simplemente procedimientos Sub o Function declarados dentro de la clase.
Por ejemplo, para crear un método Withdrawal para una clase denominada Account, se podría agregar la
función Public al módulo de la clase:
Visual Basic
Copiar código
Public Function WithDrawal(ByVal Amount As Decimal, _
ByVal TransactionCode As Byte) As Double
' Add code here to perform the withdrawal,
' return a transaction code,
' or to raise an overdraft error.
End Function
Métodos compartidos
Los métodos compartidos pueden llamarse directamente desde la clase sin necesidad de crear previamente
una instancia de la clase. Los métodos compartidos son útiles cuando se desea asociar un método con una
instancia específica de una clase. Los métodos compartidos no se pueden declarar mediante los
modificadores Overridable, NotOverridable o MustOverride. Los métodos que se declaran en módulos
están compartidos implícitamente y no pueden utilizar el modificador Shared explícitamente.
Ejemplo
Visual Basic
Copiar código
Class ShareClass
Shared Sub SharedSub()
MsgBox("Shared method.")
End Sub
End Class
Sub Test()
' Call the method.
ShareClass.SharedSub()
End Sub
Protección de los detalles de la implementación

Los procedimientos de utilidades empleados internamente por una clase se deben declarar como Private,
Protected o Friend. La restricción de la accesibilidad de tales métodos protege a los desarrolladores que
Pág 29
utilizan sus objetos, ya que le permite realizar futuros cambios sin que afecte al código que utiliza los
objetos.
La protección de los detalles de la implementación de un objeto es otra faceta de la encapsulación. La
encapsulación permite mejorar el rendimiento de los métodos o cambiar totalmente la forma de implementar
un método, sin necesidad de modificar el código que utiliza el método.
Vea también
Tareas
Conceptos
Referencia
Overridable
NotOverridable
MustOverride
Public (Visual Basic)
Private (Visual Basic)
Protected (Visual Basic)
Friend (Visual Basic)

Las propiedades y los métodos son similares en que ambos se implementan como procedimientos que
aceptan argumentos. En general, las propiedades almacenan datos para un objeto, y los métodos son
acciones cuya realización puede pedirse a un objeto. Algunas características de objeto son claramente
propiedades, como Name, mientras que otras son evidentemente métodos, como Move y Show. En otros
casos, no resulta obvio qué miembros de una clase deberían ser propiedades y cuáles deberían ser métodos.
Por ejemplo, el método Item de una clase de colección almacena y recupera datos, y puede implementarse
como una propiedad indizada. Por otra parte, también resulta razonable implementar Item como un método.
Sintaxis de propiedades frente a sintaxis de métodos
Una forma de decidir cómo implementar un miembro de una clase consiste en considerar cómo se desea
utilizar. Aunque la sintaxis para recuperar información de una propiedad parametrizada es casi idéntica a la
utilizada con un método implementado como función, la sintaxis para modificar tal valor es algo diferente.
Por ejemplo, si implementa el miembro de una clase como propiedad, la sintaxis siguiente describe cómo
debería utilizarse:
Objeto.Propiedad(Índice) = NuevoValor
Si implementa el miembro de la clase como método, el valor que se modifica debe ser un argumento. El
fragmento de código siguiente describe el uso de sintaxis equivalente:
Objeto.Propiedad(Índice, NuevoValor)
Mensajes de error
Otro factor a considerar a la hora de elegir cómo implementar un miembro de una clase es qué tipo de
mensajes se generarán cuando la clase se utilice incorrectamente. Si alguien intenta accidentalmente
asignar un valor a una propiedad de sólo lectura, el mensaje de error devuelto es distinto del que se
obtendría en respuesta a una llamada similar a un método. Los miembros de una clase implementados
correctamente devuelven mensajes de error que son más fáciles de interpretar.
Pág 30
Vea también
Tareas
Conceptos
Referencia
Item (Propiedad, objeto Collection)
Propiedades predeterminadas
Una propiedad que acepta argumentos puede declararse como propiedad predeterminada de una clase. Una
propiedad predeterminada es aquella que utiliza Visual Basic cuando no se haya asignado una propiedad
específica para un objeto. Las propiedades predeterminadas son útiles porque permiten que el código fuente
sea más compacto al omitirse nombres de propiedades que se utilizan frecuentemente.
Las mejores candidatas a propiedades predeterminadas son las propiedades que aceptan parámetros y que
se utilizarán con más frecuencia. Por ejemplo, la propiedad Item es una buena opción como propiedad
predeterminada de una clase de colección, ya que se usa con frecuencia.
Las siguientes reglas se aplican a las propiedades predeterminadas:
 Un tipo sólo puede tener una propiedad predeterminada, incluyendo las propiedades heredadas de
una clase base. Hay una excepción para esta regla. Una propiedad predeterminada definida en una
clase base puede ser sombreada por otra propiedad predeterminada de una clase derivada.
 Si una propiedad predeterminada de una clase base es sombreada por una propiedad no
predeterminada de una clase derivada, la propiedad predeterminada continúa permitiendo el acceso
mediante la sintaxis de propiedad predeterminada.
 Una propiedad predeterminada no puede ser de tipo Shared o Private.
 Si una propiedad sobrecargada es una propiedad predeterminada, también lo serán todas las demás
propiedades sobrecargadas que tengan el mismo nombre.
 Las propiedades predeterminadas deben aceptar al menos un argumento.
Ejemplo
El siguiente ejemplo declara una propiedad que contiene una matriz de cadenas como propiedad
predeterminada de una clase:
Visual Basic
Copiar código
Class Class2
' Define a local variable to store the property value.
Private PropertyValues As String()
' Define the default property.
Default Public Property Prop1(ByVal Index As Integer) As String
Get
Return PropertyValues(Index)
End Get
Set(ByVal Value As String)
If PropertyValues Is Nothing Then
' The array contains Nothing when first accessed.
Pág 31
ReDim PropertyValues(0)
Else
' Re-dimension the array to hold the new element.
ReDim Preserve PropertyValues(UBound(PropertyValues) + 1)
End If
PropertyValues(Index) = Value
End Set
End Property
End Class
Acceso a propiedades predeterminadas

El acceso a propiedades predeterminadas puede realizarse mediante sintaxis abreviada. Por ejemplo, en el
fragmento de código siguiente se utiliza sintaxis estándar y sintaxis predeterminada:
Visual Basic
Copiar código
Dim C As New Class2
' The first two lines of code access a property the standard way.
' Property assignment.

C.Prop1(0) = "Value One"
' Property retrieval.
MsgBox(C.Prop1(0))
' The following two lines of code use default property syntax.
' Property assignment.

C(1) = "Value Two"
' Property retrieval.
MsgBox(C(1))
Vea también
Conceptos
Recomendación de actualización: resolver las propiedades predeterminadas sin parámetros
Cambios en las propiedades predeterminadas para usuarios de Visual Basic 6.0
Referencia
Default (Visual Basic)

La sobrecarga consiste en crear más de un procedimiento, constructor de instancia o propiedad en una clase
con el mismo nombre y distintos tipos de argumento.
Pág 32
Uso de la sobrecarga
La sobrecarga es especialmente útil cuando un modelo de objeto exige el uso de nombres idénticos para
procedimientos que operan en diferentes tipos de datos. Por ejemplo, una clase que puede mostrar
diferentes tipos de datos podría tener procedimientos Display como los siguientes:
Visual Basic
Copiar código
Overloads Sub Display(ByVal theChar As Char)
' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
' Add code that displays Integer data.
End Sub
Overloads Sub Display(ByVal theDouble As Double)
' Add code that displays Double data.
End Sub
Sin sobrecarga, sería necesario crear distintos nombres para cada procedimiento, aunque realicen el mismo
cometido, como se muestra a continuación:
Visual Basic
Copiar código
Sub DisplayChar(ByVal theChar As Char)
' Add code that displays Char data.
End Sub
Sub DisplayInt(ByVal theInteger As Integer)
' Add code that displays Integer data.
End Sub
Sub DisplayDouble(ByVal theDouble As Double)
' Add code that displays Double data.
End Sub
La sobrecarga facilita el uso de propiedades o métodos, puesto que ofrece una selección de tipos de datos
que se pueden utilizar. Por ejemplo, se pude llamar al método sobrecargado Display descrito anteriormente
con cualquiera de las siguientes líneas de código:
Visual Basic
Copiar código
' Call Display with a literal of type Char.
Display("9"c)
' Call Display with a literal of type Integer.
Display(9)
' Call Display with a literal of type Double.
Display(9.9R)
Pág 33
En tiempo de ejecución, Visual Basic llama al procedimiento correcto basándose en los tipos de datos de los
parámetros que se han especificado.
Nota:
La sobrecarga, el reemplazo y el sombreado son conceptos similares que pueden confundirse

fácilmente. Para obtener más información, consulte Introducción a los objetos en Visual Basic.
Reglas de sobrecarga
Es posible crear un miembro sobrecargado para una clase agregando dos o más propiedades o métodos con
el mismo nombre. A excepción de los miembros derivados sobrecargados, cada miembro sobrecargado debe
tener distintas listas de parámetros, y los elementos que a continuación se enumeran, no se pueden utilizar
como características diferenciadoras al sobrecargar una propiedad o un procedimiento:
 Modificadores, como por ejemplo ByVal o ByRef, que se aplican a un miembro o parámetros de un
miembro.
 Nombres de parámetros
 Tipos de valores devueltos de procedimientos
La palabra clave Overloads es opcional en la sobrecarga, aunque si algún miembro sobrecargado la utiliza,
todos los demás miembros sobrecargados con el mismo nombre deben especificarla también.
Las clases derivadas pueden sobrecargar miembros heredados con miembros que tengan idénticos
parámetros y tipos de parámetros, un proceso denominado sombrear por nombre y firma. Si se utiliza la
palabra clave Overloads al sombrear por nombre y firma, se utilizará la implementación de la clase
derivada del miembro en vez de la implementación de la clase base y todas las demás sobrecargas de dicho
miembro estarán disponibles para las instancias de la clase derivada.
Si se omite la palabra clave Overloads al sobrecargar un miembro heredado con un miembro que tiene
parámetros y tipos de parámetros idénticos, la sobrecarga se denomina sombrear por nombre. El proceso
sombrear por nombre reemplaza a la implementación heredada de un miembro y hace que todas las demás
sobrecargas no estén disponibles para las instancias de la clase derivada y sus descendientes.
Los modificadores Overloads y Shadows no pueden utilizarse a la vez con la misma propiedad o método.
Ejemplo
El ejemplo siguiente crea métodos sobrecargados que aceptan una representación String o Decimal de una
cantidad en dólares y devuelven una cadena que contiene los impuestos sobre ventas.
Para utilizar este ejemplo para crear un método sobrecargado

1. Abra un nuevo proyecto y agregue una clase denominada TaxClass.
2. Agregue el código siguiente a la clase TaxClass.
Visual Basic
Copiar código
Public Class TaxClass
Overloads Function TaxAmount(ByVal decPrice As Decimal, _
ByVal TaxRate As Single) As String
TaxAmount = "Price is a Decimal. Tax is $" & _
(CStr(decPrice * TaxRate))
End Function
Pág 34
Overloads Function TaxAmount(ByVal strPrice As String, _

ByVal TaxRate As Single) As String
TaxAmount = "Price is a String. Tax is $" & _
CStr((CDec(strPrice) * TaxRate))
End Function
End Class
3. Agregue el procedimiento siguiente a su formulario.
Visual Basic
Copiar código
Sub ShowTax()
' 8% tax rate.
Const TaxRate As Single = 0.08
' $64.00 Purchase as a String.
Dim strPrice As String = "64.00"
' $64.00 Purchase as a Decimal.
Dim decPrice As Decimal = 64
Dim aclass As New TaxClass
'Call the same method with two different kinds of data.
MsgBox(aclass.TaxAmount(strPrice, TaxRate))
MsgBox(aclass.TaxAmount(decPrice, TaxRate))
End Sub
4. Agregue un botón al formulario y llame al procedimiento ShowTax desde el evento Button1_Click

del botón.
5. Ejecute el proyecto y haga clic en el botón del formulario para probar el procedimiento
sobrecargado ShowTax.
En tiempo de ejecución, el compilador elige la función sobrecargada adecuada que coincida con los
parámetros que se utilicen. Al hacer clic en el botón, primero se llama al método sobrecargado con un
parámetro Price que es una cadena y se muestra el mensaje: "Price is a String. Tax is $5.12". La segunda
vez se llama a TaxAmount con un valor Decimal y se muestra el mensaje, "Price is a Decimal. Tax is
$5.12".
Vea también
Conceptos
Referencia
Instrucción Sub (Visual Basic)
Shadows
ByVal
ByRef
Pág 35
Overloads
Shadows

Una clase derivada hereda las propiedades y métodos definidos en su clase base. Esto es útil porque puede
reutilizar estos elementos cuando son adecuados para la clase derivada. Si la propiedad o método en la clase
base está marcada con la palabra clave Overridable, puede definir una nueva implementación para el
miembro en la clase derivada. Utilice la palabra clave Overrides para sombrear el miembro volviéndolo a
definir en la clase derivada. Esto es útil cuando no puede utilizar el miembro "tal cual".
En la práctica, los miembros reemplazados suelen utilizarse para implementar el polimorfismo. Para obtener
más información, consulte Polimorfismo.
Las siguientes reglas se aplican a los métodos de reemplazo.
 Sólo se pueden reemplazar miembros que estén marcados con la palabra clave Overridable en la
clase base.
 De forma predeterminada, las propiedades y los métodos son NotOverridable.
 Los miembros reemplazados deben tener los mismos argumentos que los miembros heredados de
la clase base.
 La nueva implementación de un miembro puede llamar a la implementación original de la clase
primaria mediante la especificación de MyBase antes del nombre de método.
Nota:
La sobrecarga, el reemplazo y el sombreado son conceptos similares que pueden confundirse

fácilmente. Para obtener más información, consulte Introducción a los objetos en Visual Basic.
Ejemplo
Suponga que desea definir clases para controlar la nómina. Podría definir una clase genérica Payroll que
contenga un método RunPayroll para calcular la nómina de una semana típica. Podría utilizar Payroll
como clase base de una clase más especializada BonusPayroll que se utilizaría para distribuir
bonificaciones entre los empleados.
La clase BonusPayroll puede heredar y reemplazar al método PayEmployee definido en la clase base
Payroll.
En el siguiente ejemplo se define una clase base, Payroll, y una clase derivada, BonusPayroll, que
reemplaza a un método heredado, PayEmployee. Un procedimiento, RunPayroll crea y luego pasa un
objeto Payroll y un objeto BonusPayroll a una función, Pay, que ejecuta el método PayEmployee de
ambos objetos.
Visual Basic
Copiar código
Const BonusRate As Decimal = 1.45D
Const PayRate As Decimal = 14.75D
Class Payroll
Overridable Function PayEmployee( _
ByVal HoursWorked As Decimal, _
ByVal PayRate As Decimal) _
Pág 36
As Decimal
PayEmployee = HoursWorked * PayRate

End Function
End Class
Class BonusPayroll
Inherits Payroll
Overrides Function PayEmployee( _
ByVal HoursWorked As Decimal, _
ByVal PayRate As Decimal) _
As Decimal
' The following code calls the original method in the base
' class, and then modifies the returned value.
PayEmployee = MyBase.PayEmployee(HoursWorked, PayRate) *
BonusRate
End Function
End Class
Sub RunPayroll()
Dim PayrollItem As Payroll = New Payroll
Dim BonusPayrollItem As New BonusPayroll
Dim HoursWorked As Decimal = 40
MsgBox("Normal pay is: " & _

PayrollItem.PayEmployee(HoursWorked, PayRate))
MsgBox("Pay with bonus is: " & _
BonusPayrollItem.PayEmployee(HoursWorked, PayRate))
End Sub
Vea también
Conceptos
Reemplazar modificadores
Otros recursos
Polimorfismo
Pág 37
Puede utilizar los modificadores NotOverridable y MustOverride en una clase base para controlar cómo
las clases derivadas reemplazan sus propiedades y métodos.
El modificador NotOverridable define un método de una clase base que no se puede reemplazar en clases
derivadas. Todos los métodos son NotOverridable a menos que se marquen con el modificador
Overridable. Puede utilizar el modificador NotOverridable si no desea permitir que un método
reemplazado sea reemplazado de nuevo en una clase derivada.
Los métodos definidos con el modificador MustOverride no tienen ninguna implementación en la clase base
y deben implementarse en clases derivadas. Las clases que contienen métodos MustOverride deben
marcarse con el modificador MustInherit.
Ejemplo
Visual Basic
Copiar código
MustInherit Class BaseClass
Public MustOverride Sub aProcedure()
End Class
Class DerivedClass
Inherits BaseClass
Public NotOverridable Overrides Sub aProcedure()
' Override a procedure inherited from the base class
' and mark it with the NotOverridable modifier so that
' it cannot be overridden in classes derived from this class.
End Sub
End Class
Vea también
Conceptos
Contraer todo
Esta página es específica de
Microsoft Visual Studio 2008/.NET Framework 3.5
Hay además otras versiones disponibles para:
 Microsoft Visual Studio 2005/.NET Framework 2.0

Los objetos son combinaciones de código y datos que pueden tratarse como unidades individuales.
Prácticamente todas las actividades que se realizan en Visual Basic implican el uso de objetos, desde los
Pág 38
controles que se utilizan hasta los formularios en los que se colocan. En esta sección se explica dónde se
originan los objetos y la forma de utilizarlos.
En esta sección
Objetos de Visual Basic y otros orígenes
Explica cómo se utilizan los objetos de Microsoft Word, Microsoft Excel y otras aplicaciones.
Cómo: Establecer y recuperar propiedades
Explica cómo cambiar y obtener valores de propiedad.
Cómo: Realizar acciones con métodos
Explica qué son los métodos y cómo se utilizan.
Cómo: Tratar formularios como objetos
Muestra el uso de formularios como objetos ordinarios.
Cómo: Obtener acceso a un formulario
Muestra cómo tener acceso a los miembros de un formulario sin tener que crear una variable.
Cómo: Utilizar la nueva palabra clave
Muestra cómo crear instancias de formularios, clases definidas en módulos de clase y colecciones.
Administración de recursos
Explica cómo se pueden ahorrar memoria y recursos del sistema mediante la liberación de
referencias a objetos.
Cómo: Pasar objetos a procedimientos
Explica cómo pasar objetos como argumentos a los procedimientos.
Tutorial: Guardar un objeto en Visual Basic
Muestra cómo se puede utilizar la serialización para guardar los datos de un objeto entre instancias,
permitiendo así almacenar valores y recuperarlos la próxima vez que se cree una instancia del
objeto.
Cómo: Heredar de una clase en Visual Basic
Muestra cómo se define una clase base y se declaran clases que amplían la clase base.
Trata los fundamentos de la programación orientada a objetos.
Administrar grupos de objetos
Proporciona un listado de técnicas para trabajar con matrices y colecciones de objetos.
Cómo: Realizar varias acciones en un objeto
Trata el uso de la instrucción With...End With para simplificar el acceso a las propiedades.
Contraer todo

Pág 39
Los objetos que se utilizan en Visual Basic proceden de orígenes internos y externos. Entre los ejemplos de
objetos internos se incluyen los objetos y clases intrínsecos en el proyecto; entre los ejemplos de objeto
externos se incluyen los ensamblados y los objetos COM.
Objetos internos
Los objetos intrínsecos (o integrados) son los que proporciona Visual Basic de forma nativa. Entre éstos se
incluyen los tipos escalares primitivos como Integer y Double, así como los tipos Array y String. No hace
falta crear referencias a objetos internos antes de utilizarlos en el proyecto.
Otros objetos internos son instancias de clases en el proyecto actual. Estas clases pueden utilizarse siempre
que sean necesarias dentro del proyecto y pueden estar disponibles para otras aplicaciones cuando se crea
un ensamblado.
Objetos externos
Los objetos externos son los que proceden de otros proyectos o ensamblados que no están disponibles en el
proyecto de manera predeterminada. Es necesario crear referencias de proyecto a los objetos externos para
poder utilizarlos en el proyecto.
Los ensamblados son el origen más común de objetos para las aplicaciones de Visual Basic. .NET Framework
incluye ensamblados que contienen objetos que se utilizan habitualmente. Algunos objetos en .NET
Framework se tratan como objetos intrínsecos, pero la mayoría de los ensamblados deben importarse de
forma explícita mediante la instrucción Imports antes de poder utilizarlos. Cualquier lenguaje compatible
con Common Language Specification (CLS), como Visual Basic o Visual C#, puede crear y utilizar
ensamblados. Para obtener más información, consulte Ensamblados.
En el pasado, los componentes COM eran el origen tradicional de objetos para programadores de Visual
Basic, pero actualmente los ensamblados de .NET Framework constituyen una opción mejor para los nuevos
objetos. Todavía se pueden utilizar los componentes COM existentes en las aplicaciones; no obstante, el
acceso a los objetos COM debe realizarse mediante clases de interoperabilidad de .NET Framework. El acceso
a una biblioteca COM requiere el uso de un ensamblado de interoperabilidad que contenga clases de
interoperabilidad para cada clase COM definida en la biblioteca. Para obtener más información, consulte
Interoperabilidad COM.
Además de tener acceso a las clases de .NET Framework nativas y las clases COM, también es posible llamar
a las funciones definidas en bibliotecas de vínculos dinámicos (archivos DLL), como las de la API Win32.
Visual Basic le permite llamar a las funciones en archivos DLL una vez que se hayan declarado con una
instrucción Declare. Visual Basic agrega la funcionalidad a la instrucción Declare y le permite utilizar el
atributo DllImportAttribute para especificar valores predeterminados para elementos como
CallingConvention, ExactSpelling y SetLastError. Los parámetros de instrucciones Declare pueden anotarse
con el atributo MarshalAsAttribute, que admite la conversión de parámetros en formas que no eran posibles
en versiones anteriores de Visual Basic.
Vea también
Tareas
Tutorial: Implementar la herencia mediante objetos COM
Conceptos
Relaciones entre objetos
Referencia
Pág 40
Declare (Instrucción)
DllImportAttribute
Integer (Tipo de datos, Visual Basic)
Double (Tipo de datos, Visual Basic)
String (Tipo de datos, Visual Basic)
MarshalAsAttribute
Otros recursos

Las propiedades de formularios y controles en Visual Basic pueden establecerse mediante programación en
tiempo de ejecución o en modo de diseño en la ventana Propiedades. Las propiedades de la mayoría de los
objetos restantes, como los objetos de los ensamblados o los objetos que haya creado, únicamente pueden
establecerse mediante programación.
Las propiedades que se pueden establecer y leer se denominan propiedades de lectura y escritura. Las
propiedades que se pueden leer pero no modificar se denominan propiedades de sólo lectura. Las
propiedades en las que se puede escribir pero que no se pueden leer se denominan propiedades de sólo
escritura.
El valor de una propiedad se establece cuando se desea modificar el aspecto o el comportamiento de un
objeto. Por ejemplo, la propiedad Text de un control de cuadro de texto se cambia para modificar el
contenido del cuadro de texto.
El valor de una propiedad se obtiene cuando se desea conocer el estado de un objeto antes de que el código
ejecute acciones adicionales, tales como asignar el valor a otro objeto. Por ejemplo, se puede devolver la
propiedad Text de un control de cuadro de texto para determinar el contenido del cuadro de texto antes de
ejecutar un código que podría modificar el valor.
Para establecer valores de propiedad

 Utilice la sintaxis siguiente:
Objeto.propiedad=expresión
Las instrucciones siguientes proporcionan ejemplos sobre cómo establecer propiedades:
Visual Basic
Copiar código
' Set the Top property to 200 twips.
TextBox1.Top = 200
' Display the text box.
TextBox1.Visible = True
' Display 'hello' in the text box.
TextBox1.Text = "hello"
Pág 41
Nota:
También puede establecer una propiedad pasándola a parámetros ByRef, en cuyo caso la
propiedad queda modificada por el resultado devuelto por el parámetro ByRef.
Para obtener valores de propiedad

variable=Objeto.propiedad
También puede obtener un valor de propiedad como parte de una expresión más compleja, sin
asignar la propiedad a una variable. El siguiente código modifica la propiedad Top de un control de
botón de opción:
Visual Basic
Copiar código
RadioButton1.Top += 20
Vea también
Tareas
Conceptos
Otros recursos

Los métodos son procedimientos asociados a objetos. Excepto los campos y las propiedades, que
representan información que puede almacenar un objeto, los métodos representan acciones que puede
realizar un objeto. Los métodos pueden afectar a los valores de las propiedades. Por ejemplo, en el caso de
una analogía de radio, se puede emplear un método SetVolume para cambiar el valor de una propiedad
Volume. De igual forma, en Visual Basic, los elementos de cuadros de lista tienen una propiedad List que
puede cambiar con los métodos Clear y Add.
Al utilizar un método en código, la forma de crear la instrucción depende de cuántos argumentos requiere el
método y de si devuelve un valor. Generalmente, los métodos se utilizan igual que las subrutinas o las
llamadas de función. De forma más específica, los métodos se invocan del mismo modo que los
procedimientos de módulos, exceptuando que los métodos se pueden calificar con una expresión
especificando la instancia del objeto a cuyo método debe llamarse. Si no está calificada, la instancia es de
forma implícita la variable Me.
Para utilizar un método que no requiera argumentos

Objeto.método()
En el ejemplo siguiente, el método Refresh vuelve a dibujar el cuadro de imagen:
Pág 42
Visual Basic
Copiar código
' Force the control to repaint.
PictureBox1.Refresh()
Nota:
Algunos métodos, como Refresh, no tienen argumentos y no devuelven valores.
Para utilizar un método que requiera varios argumentos

 Ponga los argumentos entre paréntesis y sepárelos mediante comas. En el ejemplo siguiente, el
método MsgBox utiliza argumentos que especifican el mensaje que se debe mostrar y el estilo del
cuadro de mensaje:
Visual Basic
Copiar código
MsgBox("Database update complete", _
MsgBoxStyle.OKOnly Or MsgBoxStyle.Exclamation, _
"My Application")
Para utilizar un método que devuelva un valor

 Asigne el valor devuelto a una variable o utilice directamente la llamada al método como parámetro
para otra llamada. El código siguiente almacena el valor devuelto:
Visual Basic
Copiar código
Dim Response As MsgBoxResult
Response = MsgBox("Do you want to exit?", _
MsgBoxStyle.YesNo Or MsgBoxStyle.Question, _
"My Application")
Este ejemplo utiliza el valor devuelto desde el método Len como un argumento para MsgBox.
Visual Basic
Copiar código
Dim TestStr As String = "Some String"
' Display the string "String length is : 11".
MsgBox("String length is : " & Len(TestStr))
Pág 43
Vea también
Tareas
Conceptos
Relaciones entre objetos
Otros recursos
Cómo: Tratar formularios como objetos

Los formularios son objetos gráficos que componen la interfaz de usuario de una aplicación. Dentro de Visual
Basic, las clases definen cómo se muestran los formularios y qué pueden hacer. Cuando se muestra un
formulario en tiempo de ejecución, Visual Basic crea una instancia de la clase Form que se puede utilizar
como cualquier otro objeto. Puede agregar propiedades y métodos personalizados a formularios y tener
acceso a ellos desde otros formularios o clases de la aplicación.
Para crear un método nuevo para un formulario

 Agregue un procedimiento declarado como Public, como en el código siguiente:
Visual Basic
Copiar código
' Create a custom method on a form.
Public Sub PrintMyJob()
' Insert the code for your method here.
End Sub
Para agregar un campo nuevo a un formulario

 Declare una variable pública en el módulo del formulario, como en el código siguiente:
Visual Basic
Copiar código
Public IDNumber As Integer
Para tener acceso a métodos de un formulario distinto

1. Cree una nueva instancia del formulario a cuyos métodos desea obtener acceso. Cuando hace
referencia a un nombre de formulario, en realidad, está haciendo referencia a la clase a la cual
pertenece el formulario, no propiamente al objeto.
Nota:
Visual Basic proporciona el mismo nombre a una variable global implícita que el formulario para
Pág 44
cada clase de formulario. Para obtener más información, consulte Cómo: Obtener acceso a un
formulario.
2. Asigne el formulario a una variable de objeto. La variable de objeto hace referencia a una instancia
nueva de la clase de formulario.
El ejemplo siguiente llama correctamente al procedimiento PrintMyJob:
Visual Basic
Copiar código
Dim newForm1 As New Form1
newForm1.PrintMyJob()
En el ejemplo anterior, no se muestra el formulario nuevo. No es necesario mostrar un objeto de

formulario para utilizar sus métodos. Para mostrar el formulario nuevo, debe agregar el código
siguiente:
Visual Basic
Copiar código
newForm1.Show()
Vea también
Tareas
Conceptos
Procedimientos de propiedad
Cómo: Obtener acceso a un formulario

Puede tener acceso a los miembros de un formulario de Visual Basic sin tener que crear una variable. Los
ejemplos siguientes muestran esto cambiando los colores en un formulario.
Tener acceso a un formulario
Para tener acceso a Form1

1. Asegúrese de que su proyecto tiene una referencia al espacio de nombres System.Drawing. Esto es
necesario para trabajar con la configuración de colores, no para tener acceso al formulario.
2. Cambie los colores directamente en Form1.
3. Llame directamente al método Show en Form1.
Visual Basic
Copiar código
Public Sub ChangeForm1Colors()
Form1.ForeColor = System.Drawing.Color.Coral
Pág 45
Form1.BackColor = System.Drawing.Color.Cyan
Form1.Show()
End Sub
Si Form1 no existe, Visual Basic lo creará. No tiene que declarar una variable para él.
Crear una instancia adicional de un formulario
Si desea crear un nuevo formulario, en lugar de tener acceso a uno existente, puede declarar una variable e
inicializarla utilizando la palabra clave New.
Para crear una copia adicional de Form1

1. Asegúrese de que su proyecto tiene una referencia al espacio de nombres System.Drawing. Esto es
necesario para trabajar con la configuración de colores, no para tener acceso al formulario.
2. Asigne New Form1 a una variable.
Visual Basic
Copiar código
Public Sub GetSecondInstance()
newForm1.BackColor = System.Drawing.Color.YellowGreen
newForm1.Show()
End Sub
Si desea mostrar dos o más copias del mismo formulario, debe crear copias adicionales. El ejemplo
anterior crea una segunda copia de Form1 y lo pinta de un color diferente. Puede tener acceso a la
copia original utilizando Form1 y a la segunda copia mediante newForm1.
Vea también
Referencia
System.Drawing
Form
New (Visual Basic)

Para crear una instancia de una clase, utilice la palabra clave New. A diferencia de los tipos de valor, como
Integer y Double, los objetos son tipos de referencia, y debe crearlos de forma explícita antes de poder
utilizarlos. Por ejemplo, observe las siguientes dos líneas de código:
Visual Basic
Copiar código
Dim Button1 As System.Windows.Forms.Button
Dim Button2 As New System.Windows.Forms.Button()
La primera instrucción declara una variable de objeto que puede contener una referencia a un objeto de
botón. Sin embargo, la variable Button1 contiene el valor Nothing hasta que le asigne un objeto de tipo
Pág 46
Button. La segunda instrucción también define una variable que puede contener un objeto de botón, pero la
palabra clave New crea un objeto de botón y lo asigna a la variable Button2.
Como los formularios y controles son en realidad clases, puede utilizar la palabra clave New para crear
instancias nuevas de estos elementos, cuando sea necesario.
Para crear instancias nuevas de una clase con New

1. Abra un nuevo proyecto de aplicación para Windows, y coloque un botón de comando y otros
controles diversos en un formulario denominado Form1.
2. Agregue el código siguiente al procedimiento de evento Click del botón de comando:
Visual Basic
Copiar código
Dim f As New Form1
f.Show()
3. Ejecute la aplicación, y haga clic en el botón de comando varias veces.

4. Coloque a un lado el formulario frontal. Como el formulario es una clase con una interfaz visible,
puede ver las copias adicionales. Cada copia tiene los mismos controles, en la misma posición que
los del formulario original en tiempo de diseño.
Puede utilizar la palabra clave New para crear objetos desde dentro de las clases. El procedimiento siguiente
proporciona un ejemplo.
Para ver cómo New crea instancias de una clase

1. Abra un proyecto nuevo, y coloque un botón de comando en un formulario denominado Form1.
2. En el menú Proyecto, elija Agregar clase para agregar una clase al proyecto.
3. Ponga a la clase nueva el nombre de ShowMe.vb.
4. Agregue el procedimiento siguiente a ShowMe:
Visual Basic
Copiar código
Public Class ShowMe
Sub ShowFrm()
Dim frmNew As Form1
frmNew = New Form1
frmNew.Show()
frmNew.WindowState = FormWindowState.Minimized
End Sub
End Class
5. Agregue el código siguiente para controlar el evento Click de Button1 de su formulario:
Visual Basic
Pág 47
Copiar código
Protected Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Dim clsNew As New ShowMe
clsNew.ShowFrm()
End Sub
6. Para utilizar este ejemplo, ejecute la aplicación y haga clic en el botón de comando varias veces.
Aparecerá un icono minimizado de formulario en la barra de tareas cada vez que se cree una
instancia nueva de la clase ShowMe.
Vea también
Otros recursos
Todos los objetos consumen recursos del sistema, como memoria, identificadores de archivo y conexiones de
bases de datos. Common Language Runtime (CLR) administra los recursos automáticamente y generalmente
no hay que preocuparse de liberar los objetos innecesarios. No obstante, comprender cómo funciona la
administración de recursos puede ayudarle a diseñar las aplicaciones más eficazmente.
Recolección de elementos no utilizados
CLR utiliza un sistema denominado recolección de elementos no utilizados para administrar los recursos
asignados. La recolección de elementos no utilizados del sistema libera los recursos de un objeto cuando la
ejecución de código de la aplicación ya no puede tener acceso al objeto. El algoritmo de la recolección de
elementos no utilizados es no determinista, por lo que no se puede determinar cuándo los CLR liberarán los
recursos de un objeto. En las siguientes secciones se describen algunos de los cambios en la forma de
administrar los recursos en Visual Basic.
Asignar objetos a Nothing
Nothing es una palabra clave utilizada por Visual Basic para indicar que una variable de objeto no contiene
una referencia a un objeto. En las versiones anteriores de Visual Basic se recomendaba asignar los objetos
no utilizados a Nothing para disociar la variable de objeto y liberar recursos. Aún pueden asignarse objetos
no utilizados a Nothing, pero debido a la forma en que Visual Basic administra los recursos, este proceso no
garantiza que los objetos queden liberados inmediatamente. En general, sólo se deben asignar a Nothing
objetos duraderos (como miembros compartidos o variables globales).
Desechar
Algunos objetos admiten un método denominado Dispose cuya finalidad consiste en liberar recursos del
sistema de forma más expeditiva. Las clases que admiten el método Dispose deben implementar la interfaz
IDisposable. Es necesario llamar explícitamente al método Dispose cuando se deseen liberar recursos de
objetos. Por ejemplo:
ThisObject.Dispose()
Finalize
Otro método que admiten algunas clases, Finalize, se ejecuta automáticamente cuando se libera un objeto y
puede utilizarse para realizar otras tareas de limpieza. El método Finalize es similar al método
Class_Terminate() utilizado en versiones anteriores de Visual Basic. Después de que un objeto quede
inaccesible, CLR llamará en el futuro al método Finalize del objeto. Dado que el algoritmo de la recolección
Pág 48
de elementos no utilizados es no determinista, se podría llamar al método Finalize inmediatamente o

después varias horas.
Vea también
Conceptos
Inicialización y finalización de componentes
Referencia
Nothing (Visual Basic)
Dispose
IDisposable
Cómo: Pasar objetos a procedimientos

Visual Basic permite pasar objetos como argumentos a procedimientos del mismo modo en que se pasan
otros tipos de argumentos. Los procedimientos siguientes le mostrarán cómo hacerlo.
Para pasar una instancia nueva de un formulario a un procedimiento

1. Abra un proyecto, cree un formulario nuevo llamado Form1 y agréguele un botón de comando
denominado Button1.
2. Copie el código siguiente en el formulario:
Visual Basic
Copiar código
Private Sub Button1_Click(ByVal sender As Object, _
Dim newForm As New Form1

newForm.Show()
CenterForm(newForm)
End Sub
Sub CenterForm(ByVal TheForm As Form)

' Centers the form on the screen.
Dim RecForm As Rectangle = Screen.GetBounds(TheForm)
TheForm.Left = CInt((RecForm.Width - TheForm.Width) / 2)
TheForm.Top = CInt((RecForm.Height - TheForm.Height) / 2)
End Sub
También puede pasar un objeto como un argumento por referencia y posteriormente, en el

procedimiento, establecer el argumento a un objeto nuevo.
Pág 49
Para pasar una referencia de objeto a un procedimiento de otro formulario

1. Abra un proyecto y cree un formulario denominado Form1.
2. Agregue un segundo formulario denominado Form2.
3. Coloque un control de cuadro de imagen en cada formulario.
4. Ponga al cuadro de imagen de Form1 el nombre de PictureBox1.
5. Ponga al cuadro de imagen de Form2 el nombre de PictureBox2.
6. Asigne una imagen a PictureBox2 haciendo clic en la propiedad Image de la ventana Propiedades.
Funcionará cualquier imagen pequeña; encontrará archivos .bmp y .jpg en el directorio de
Windows.
7. Agregue el código siguiente a Form2:
Visual Basic
Copiar código
Public Sub GetPicture(ByVal x As PictureBox)
Dim objX As PictureBox
' Assign the passed-in picture box to an object variable.
objX = x
' Assign the value of the Picture property to the Form1 picture
box.
objX.Image = PictureBox2.Image
End Sub
8. Agregue el código siguiente al evento Form1_Click de Form1:
Visual Basic
Copiar código
Protected Sub Form1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs)
newForm2.GetPicture(PictureBox1)
End Sub
9. Ejecute la aplicación y haga clic en Form1. La imagen de Form2 aparece en el cuadro de imagen de
Form1.
El procedimiento de evento Form1_Click llama al procedimiento GetPicture de Form2 y le pasa
el cuadro de imagen vacío. El procedimiento GetPicture de Form2 asigna la propiedad Image del
cuadro de imagen de Form2 al cuadro de imagen vacío de Form1, y la imagen de Form2 se muestra
en Form1.
Vea también
Conceptos
Otros recursos
Pág 50

Programar con componentes
Tutorial: Guardar un objeto en Visual Basic

Aunque en tiempo de diseño se pueden establecer las propiedades de un objeto en valores predeterminados,
cualquier valor introducido en tiempo de ejecución se pierde cuando se destruye el objeto. Puede usar la
serialización en Visual Basic para guardar los datos de un objeto entre instancias, lo que permite almacenar
valores y recuperarlos la próxima vez que se cree una instancia del objeto.
Para almacenar datos simples, como un nombre o un número, puede usar el objeto My.Settings. Para
obtener más información, vea My.Settings (Objeto).
En este tutorial, creará un objeto Loan simple y guardará sus datos en un archivo. Recuperará a
continuación los datos del archivo al volver a crear el objeto. Por último, modificará el código para almacenar
el objeto con un formato SOAP.
Nota de seguridad:
En este ejemplo se crea un nuevo archivo, si el archivo no existe ya. Si una aplicación debe crear
un archivo, necesitará tener permisos Create en la carpeta correspondiente. Los permisos se
establecen usando listas de control de acceso. Sin embargo, si el archivo ya existe, la aplicación
sólo precisará el permiso de Write, un permiso menor. Por tanto, siempre que sea posible, resulta
más seguro crear el archivo durante la implementación y conceder sólo permisos Read a un único
archivo (en lugar de conceder permisos Create a una carpeta). También es más seguro escribir
datos en carpetas de usuario que en la carpeta raíz o en la carpeta Archivos de programa.
Nota de seguridad:
En este ejemplo se almacenan datos en un formato de archivo binario o SOAP. Estos formatos no
se deben usar con datos confidenciales, como contraseñas o información de la tarjeta de crédito.
Nota:
Ayuda, dependiendo de los valores de configuración o de edición activos. Para cambiar su
configuración, haga clic en Importar y exportar configuraciones en el menú Herramientas. Para
Crear el objeto Loan

El primer paso consiste en crear una clase Loan y una aplicación de prueba que utilice esta clase.
Para crear la clase Loan

1. Cree un nuevo proyecto Biblioteca de clases y denomínelo "LoanClass". Para obtener más
información, vea Cómo: Crear soluciones y proyectos.
2. En el Editor de código, cambie el nombre de la clase de "Class1" a "Loan".
3. Agregue a la clase los miembros públicos siguientes:
Visual Basic
Copiar código
Pág 51
Public LoanAmount As Double = 10000.0

Public InterestRate As Double = 7.5
Public Term As Integer = 36
Public Customer As String
También tendrá que crear una aplicación simple que utilice la clase Loan.
Para crear una aplicación de prueba

1. Para agregar un proyecto de aplicación para Windows a la solución, haga clic en el menú Archivo, a
continuación en Agregar y, por último, en Nuevo proyecto.
2. En el cuadro de diálogo Agregar nuevo proyecto, escriba LoanApp como el nombre del proyecto y
haga clic en Aceptar para cerrar el cuadro de diálogo.
3. En el Explorador de soluciones, seleccione el proyecto LoanApp.
4. En el menú Proyecto, haga clic en Establecer como proyecto de inicio.
5. En el menú Proyecto, haga clic en Agregar referencia.
6. En el cuadro de diálogo Agregar referencia, haga clic en la ficha Proyectos y seleccione el proyecto
LoanClass.
7. Haga clic en Aceptar para cerrar el cuadro de diálogo.
8. En el diseñador, agregue cuatro controles TextBox al formulario.
9. En el Editor de códigos, agregue el siguiente código:
Visual Basic
Copiar código
Private TestLoan As New LoanClass.Loan
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles MyBase.Load
TextBox1.Text = TestLoan.LoanAmount.ToString
TextBox2.Text = TestLoan.InterestRate.ToString
TextBox3.Text = TestLoan.Term.ToString
TextBox4.Text = TestLoan.Customer
End Sub
Llegado este punto, puede generar y ejecutar la aplicación. Observe que los valores predeterminados de la
clase Loan aparecen en los cuadros de texto. Pruebe a cambiar el valor del tipo de interés de 7,5 a 7,1 y, a
continuación, cierre la aplicación y ejecútela de nuevo; el valor vuelve a ser el predeterminado de 7,5.
En el mundo real, los tipos de interés cambian periódicamente, pero no forzosamente cada vez que se
ejecuta la aplicación. En lugar de hacer que el usuario actualice el tipo de interés cada vez que se ejecute la
aplicación, sería mejor guardar el tipo de interés más reciente entre las instancias de la aplicación. En el
paso siguiente, hará exactamente eso agregando la serialización a la clase Loan.
Usar serialización para guardar el objeto
Para guardar los valores de la clase Loan, primero debe marcarse la clase con el atributo Serializable.
Para marcar una clase como serializable

 Cambie la declaración de la clase Loan del modo siguiente:
Pág 52
Visual Basic
Copiar código
<Serializable()> Public Class Loan
El atributo Serializable indica al compilador que todo el contenido de la clase se puede guardar en un
archivo. En este caso, es probable que sólo desee guardar el miembro InterestRate, y no los miembros
Customer, LoanAmount o Period. El atributo NonSerialized se puede utilizar para marcar miembros de
clase que no deberían guardarse. Por razones de simplicidad, en este ejemplo se guarda todo excepto el
miembro Customer.
Para evitar que un miembro se serialice

 Cambie la declaración del miembro Customer del modo siguiente:
Visual Basic
Copiar código
<NonSerialized()> Public Customer As String
El paso siguiente es agregar el código de serialización a la aplicación LoanApp. Para serializar la clase y
escribirla en un archivo, utilizará los espacios de nombres System.IO y System.Xml.Serialization. Para no
tener que escribir los nombres completos, puede usar la instrucción Imports.
Para agregar referencias a espacios de nombres

 Agregue las siguientes instrucciones Imports al comienzo de la clase Form1:
Visual Basic
Copiar código
Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary
En este caso, está usando un formateador para guardar el objeto en un formato binario. Más
adelante en este tutorial modificará el código para guardar el objeto en un formato SOAP.
El paso siguiente es agregar código para deserializar el objeto del archivo cuando se cree.
Para deserializar un objeto

1. Agregue una constante a la clase para el nombre de archivo de datos serializados.
Visual Basic
Copiar código
Const FileName As String = "SavedLoan.bin"
2. Modifique el código del procedimiento de evento Form1_Load del modo siguiente:
Pág 53
Visual Basic
Copiar código
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As _
System.EventArgs) Handles MyBase.Load
If File.Exists(FileName) Then
Dim TestFileStream As Stream = File.OpenRead(FileName)
Dim deserializer As New BinaryFormatter
TestLoan = CType(deserializer.Deserialize(TestFileStream),
LoanClass.Loan)
TestFileStream.Close()
End If
TextBox1.Text = TestLoan.LoanAmount.ToString
TextBox2.Text = TestLoan.InterestRate.ToString
TextBox3.Text = TestLoan.Term.ToString
TextBox4.Text = TestLoan.Customer
End Sub
Observe que primero tiene que comprobar que el archivo existe. Si es así, cree una clase Stream
para leer el archivo binario y una clase BinaryFormatter para traducirlo. El método CType se usa
para convertir del tipo de la secuencia al tipo del objeto Loan.
A continuación, tiene que agregar código para guardar los datos introducidos en los cuadros de texto de la
clase Loan y, a continuación, debe serializar la clase en un archivo.
Para guardar los datos y serializar la clase

 Agregue el siguiente código al procedimiento de evento Form1_Closing:
Visual Basic
Copiar código
Private Sub Form1_Closing(ByVal sender As System.Object, ByVal e As
_
System.ComponentModel.CancelEventArgs) Handles MyBase.Closing
TestLoan.LoanAmount = CType(TextBox1.Text, Double)
TestLoan.InterestRate = CType(TextBox2.Text, Double)
TestLoan.Term = CType(TextBox3.Text, Integer)
TestLoan.Customer = TextBox4.Text
Dim TestFileStream As Stream = File.Create(FileName)

Dim serializer As New BinaryFormatter
serializer.Serialize(TestFileStream, TestLoan)
TestFileStream.Close()
Pág 54
End Sub
Llegado este punto, puede volver a generar y ejecutar la aplicación. Inicialmente, los valores
predeterminados aparecen en los cuadros de texto. Pruebe a cambiar los valores e introducir un nombre en
el cuarto cuadro de texto. Cierre la aplicación y, a continuación, ejecútela de nuevo. Observe que los valores
nuevos aparecen ahora en los cuadros de texto, excepto el nombre del cliente que se marcó como
NonSerialized.
Guardar el objeto con un formato SOAP
En este ejemplo se ha mostrado hasta ahora cómo guardar un objeto en un archivo de texto usando un
formato binario, que resulta correcto para la mayoría de las aplicaciones Windows; sin embargo, para las
aplicaciones web o los servicios web XML, es conveniente guardar el objeto en un archivo XML mediante un
formato SOAP, que facilita compartir el objeto.
Para guardar el objeto en un formato SOAP, primero debe hacerse referencia a la clase SoapFormatter. La
clase SoapFormatter reside en su propio espacio de nombres:
System.Runtime.Serialization.Formatters.Soap.
Para guardar el objeto con un formato SOAP

1. En el Explorador de soluciones, seleccione el proyecto LoanApp.
3. En el cuadro de diálogo Agregar referencia, haga clic en la ficha .NET y seleccione el componente
System.Runtime.Serialization.Formatters.Soap.
4. Haga clic en Aceptar para cerrar el cuadro de diálogo.
5. En el Editor de código, agregue una instrucción Imports al comienzo del módulo Form1:
Visual Basic
Copiar código
Imports System.Runtime.Serialization.Formatters.Soap
6. Cambie el nombre de archivo de SavedLoan.bin a SavedLoan.xml.

7. En el procedimiento de evento Form1_Load, cambie la instrucción Dim de Dim deserializer As
New BinaryFormatter a:
Visual Basic
Copiar código
Dim deserializer As New SoapFormatter
8. En el procedimiento de evento Form1_Closing, cambie la instrucción Dim de Dim serializer As

New BinaryFormatter a:
Visual Basic
Copiar código
Dim serializer As New SoapFormatter
Pág 55
Llegado este punto, puede generar y probar la aplicación. La primera vez que ejecute la aplicación, se creará
el archivo SavedLoan.xml. Para ver el archivo, elija la opción Mostrar todos los archivos en el Explorador de
soluciones; se encuentra en el nodo Bin del proyecto de aplicación para Windows.
Nota:
Si ya se encuentra en el modo Mostrar todos los archivos, para ver el archivo tendrá que actualizar
la vista; para ello, seleccione Actualizar en el menú Ver.
Observe que los tres miembros de la clase LoanClass se muestran en formato XML. Cambie el valor de
InterestRate en el archivo XML, a continuación guárdelo y ejecute la aplicación de nuevo. El nuevo tipo de
interés aparecerá en el segundo cuadro de texto.
Vea también
Conceptos
Equivalentes de PropertyBag para usuarios de Visual Basic 6.0
Fundamentos de la serialización de .NET Framework
Cómo: Heredar de una clase en Visual Basic

Este ejemplo define las clases Circle y Rectangle que los dos heredan de la clase Shape y la clase Square
que hereda de la clase Rectangle.
Ejemplo
Este ejemplo de código también está disponible en el fragmento de código de IntelliSense. En el selector de
Visual Basic
Copiar código
Public Class Shape
' Definitions of properties, methods, fields, and events.
End Class
Public Class Circle : Inherits Shape
' Specialized properties, methods, fields, events for Circle.
End Class
Public Class Rectangle : Inherits Shape
' Specialized properties, methods, fields, events for Rectangle.
End Class
Public Class Square : Inherits Rectangle
' Specialized properties, methods, fields, events for Square.
End Class
Compilar el código
Este ejemplo necesita:
 Una referencia al espacio de nombres System.
Nota:
Pág 56
Asegúrese de que la clase desde la que desea heredar no está definida como NotInheritable.
Vea también
Tareas
Cómo: Dibujar una forma con contorno
Referencia
NotInheritable
Otros recursos
Cómo: Leer datos de objetos de un archivo XML en Visual

Basic
En este ejemplo se leen datos de objetos escritos previamente en un archivo XML mediante la clase
XmlSerializer.
Ejemplo
Este ejemplo de código también está disponible en el fragmento de código de IntelliSense. En el selector de
fragmentos de código, se encuentra en XML. Para obtener más información, vea Cómo: Insertar fragmentos
de código en el código (Visual Basic).
Visual Basic
Copiar código
Public Class Book
Public Title As String
Public Sub New()
End Sub
End Class
Public Sub ReadXML()

Dim reader As New
System.Xml.Serialization.XmlSerializer(GetType(Book))
Dim file As New System.IO.StreamReader("c:\IntroToVB.xml")
Dim introToVB As Book
introToVB = CType(reader.Deserialize(file), Book)
End Sub
Compilar el código
Sustituya el nombre de archivo "c:\IntroToVB.xml" por el nombre del archivo que contenga los datos
serializados. Para obtener más información sobre datos de serialización, consulte Cómo: Escribir datos de
objetos en un archivo XML de Visual Basic.
La clase debe tener un constructor público sin parámetros.
Sólo se deserializan propiedades y campos públicos.
Pág 57
Las condiciones siguientes pueden producir una excepción:

 La clase que se va a serializar no tiene un constructor público sin parámetros.
 Los datos del archivo no representan datos de la clase que se va a deserializar.
 El archivo no existe (IOException).
Seguridad
Compruebe siempre las entradas y nunca deserialice datos procedentes de un origen que no sea de
confianza. El objeto recreado se ejecuta en un equipo local con los permisos del código que lo deserializó.
Compruebe todas las entradas antes de utilizar los datos en la aplicación.
Vea también
Tareas
Cómo: Escribir datos de objetos en un archivo XML de Visual Basic
Cómo: Leer texto de archivos con Streamreader (Visual Basic)
Referencia
StreamWriter
Cómo: Escribir datos de objetos en un archivo XML de Visual

Basic
En este ejemplo se escribe el objeto de una clase en un archivo XML mediante la clase XmlSerializer.
Ejemplo
En este ejemplo de código se define una clase denominada Book, se crea una instancia de la clase y se
utiliza la serialización XML para escribir la instancia en un archivo XML.
Código parecido a éste está disponible como fragmentos de código de IntelliSense. En el selector de
fragmentos de código, se encuentra en XML. Para obtener más información, vea Cómo: Insertar fragmentos
de código en el código (Visual Basic).
Visual Basic
Copiar código
Public Class Book
Public Title As String
Public Sub New()
End Sub
End Class
Public Sub WriteXML()

Dim introToVB As New Book
introToVB.Title = "Intro to Visual Basic"
Dim writer As New
System.Xml.Serialization.XmlSerializer(GetType(Book))
Dim file As New System.IO.StreamWriter("c:\IntroToVB.xml")
writer.Serialize(file, introToVB)
file.Close()
End Sub
Pág 58
Compilar el código
La clase debe tener un constructor público sin parámetros.
Las condiciones siguientes pueden producir una excepción:
 La clase que se va a serializar no tiene un constructor público sin parámetros.
 El archivo ya existe y es de sólo lectura (IOException).
 La ruta de acceso es demasiado larga (PathTooLongException).
 El disco está lleno (IOException).
Seguridad
Este ejemplo crea un nuevo archivo, si el archivo no existe ya. Si una aplicación necesita crear un archivo,
precisará acceso Create para la carpeta correspondiente. Sin embargo, si el archivo ya existe, la aplicación
sólo precisará acceso Write, un privilegio menor. Por tanto, siempre que sea posible, resulta más seguro
crear el archivo durante la implementación y conceder sólo acceso Read para un único archivo, en lugar de
acceso Create para una carpeta.
Vea también
Tareas
Cómo: Leer datos de objetos de un archivo XML en Visual Basic
Referencia
StreamWriter
Otros recursos
Acceso a archivos con Visual Basic

En términos generales, una colección es un objeto utilizado para agrupar y administrar objetos relacionados.
Por ejemplo, cada formulario Form tiene una colección de controles. (Puede tener acceso a esta colección a
través de la propiedad Controls del formulario.) Esta colección es un objeto que representa todos los
controles de ese formulario. Le permite recuperar un control de la colección utilizando su índice y recorrer en
iteración los elementos de la colección utilizando una Instrucción For Each...Next (Visual Basic).
Sin embargo, hay varios tipos de colecciones y se diferencian entre sí de varias maneras.
Diferentes tipos de colecciones
Visual Basic también proporciona una clase Collection, con la que puede definir y crear sus propias
colecciones. Al igual que la colección Controls de un formulario, la clase Collection también proporciona la
funcionalidad integrada que permite recorrer en iteración los miembros mediante For Each...Next y
recuperar los elementos usando su índice. Para obtener más información, vea Collection (Objeto, Visual
Basic).
Sin embargo, los dos tipos de colecciones no interoperan entre sí. Por ejemplo, el código siguiente genera un
error del compilador:
Dim localControls As Collection
' The following line generates a COMPILER ERROR.
localControls = Me.Controls()
Las colecciones son incompatibles porque la colección Controls es una colección de .NET Framework,
mientras que la variable localControls es una Collection de Visual Basic. Los dos tipos de colecciones se
implementan a partir de distintas clases. Sus métodos son similares pero no idénticos y sus esquemas de
indización son diferentes.
Colecciones basadas en cero y en uno
Pág 59
Una colección puede ser basada en cero o basada en uno, según cuál sea su índice de comienzo. La primera
de ellas significa que el índice del primer elemento de la colección es 0, y la última, que es 1. Un ejemplo de
colección basada en cero es la colección Controls de .NET Framework, explicada anteriormente en esta
página. El objeto Collection de Visual Basic es un ejemplo de una colección basada en uno.
Las colecciones basadas en uno pueden resultar más intuitivas para los usuarios de Visual Basic, porque el
intervalo del índice se extiende desde 1 hasta el valor de Count (Propiedad, objeto Collection), que devuelve
el número de elementos existentes en una colección. En cambio, el índice de una colección basada en cero
varía desde cero hasta el valor de la propiedad Count menos uno. Esto puede ser adecuado cuando los
valores de índice son desplazamientos respecto a un valor base o corresponder a miembros de una
enumeración basada en cero.
Las colecciones de .NET Framework están basadas en cero con el fin de seguir un esquema estándar. La
clase Collection de Visual Basic está basada en uno con el fin de proporcionar compatibilidad con versiones
anteriores.
Valores de índice y de clave
Las instancias de la clase Collection de Visual Basic permiten tener acceso a un elemento utilizando un índice
numérico o una clave String. Puede agregar elementos a los objetos Collection de Visual Basic especificando
una clave o sin especificarla. Si agrega un elemento sin una clave, debe utilizar su índice numérico para
tener acceso a él.
Por contraste, las colecciones como System.Collections..::.ArrayList sólo permiten un índice numérico. No se
pueden asociar claves con los elementos de estas colecciones, a menos que construya las suyas propias
basadas en asignaciones, por ejemplo, en una matriz de String que contiene las claves.
Agregar y quitar elementos
Las colecciones se diferencian en si se les puede o no agregar elementos y, en caso afirmativo, en cómo se
pueden agregar. Puesto que el objeto Collection de Visual Basic es una herramienta de programación de uso
general, es más flexible que algunas otras colecciones. Tiene un Add (Método, objeto Collection) para colocar
elementos en la colección y un Remove (Método, objeto Collection) para quitar elementos de ella.
Por otra parte, ciertas colecciones especializadas no permiten agregar o quitar elementos mediante código.
Por ejemplo, la propiedad CheckedListBox..::.CheckedItems devuelve una colección de referencias a
elementos por índice, pero su código no puede agregar elementos a la colección ni quitarlos de ella. Sólo el
usuario puede hacer esta operación, activando o desactivando la casilla de verificación correspondiente en la
interfaz de usuario. Por tanto, no hay ningún método Add ni Remove para esta colección.
Vea también
Tareas
Cómo: Crear una colección de objetos
Cómo: Crear una matriz de objetos
Cómo: Agregar, eliminar y recuperar los elementos de una colección
Cómo: Definir colecciones en clases propias
Cómo: Recorrer en iteración una colección de Visual Basic
Solucionar problemas de colecciones
Conceptos
Clase de colección de Visual Basic
Pág 60

En muchas aplicaciones se desea poder crear y administrar grupos de objetos relacionados. Existen dos
formas de agrupar objetos: mediante la creación de matrices de objetos y mediante la creación de
colecciones de objetos.
Matrices de objetos
Las matrices son estructuras relativamente inflexibles. Si desea cambiar el tamaño de una matriz en tiempo
de ejecución, debe utilizar Instrucción ReDim (Visual Basic) para volver a declararla. Todos los elementos de
la matriz deben ser del mismo tipo. Por otra parte, las matrices permiten procesar secuencialmente todos los
elementos y pueden existir elementos de una matriz vacíos. Por estos motivos, las matrices son muy útiles
para crear y trabajar con un número fijo de objetos con establecimiento inflexible de tipos.
Para obtener más información, consulte Cómo: Crear una matriz de objetos.
Colecciones de objetos
Las colecciones proporcionan un método más flexible de trabajar con grupos de objetos. Una colección es
una clase, de modo que antes de poder agregar elementos a una nueva colección, debe declararla. A
diferencia de las matrices, el grupo de objetos con el que trabaja puede aumentar y reducirse
dinámicamente a medida que cambian las necesidades de la aplicación. Puede asignar una clave a cualquier
objeto que incluya en una colección, de manera que puede recuperarlo y manipularlo basándose en esa
clave.
Puede crear una colección generalizada a partir de Clase de colección de Visual Basic. Si quiere una
funcionalidad específica en una colección, por ejemplo un diccionario o una lista vinculada, puede crearla a
partir de una de las clases en el espacio de nombres System.Collections de .NET Framework. Las clases de
colecciones especializadas están disponibles en el espacio de nombres System.Collections.Specialized.
Si su colección se limita a los elementos de sólo un tipo de datos, puede utilizar una de las clases en el
espacio de nombres System.Collections.Generic. Una colección genérica cumple la seguridad de tipos para
que ningún otro tipo de datos se pueda agregar a ella. Cuando recupera un elemento de una colección
genérica, no tiene que determinar su tipo de datos ni convertirlo.
Para obtener más información, consulte Cómo: Crear una colección de objetos.
Vea también
Tareas
Conceptos
Referencia
System.Collections
System.Collections.Generic
System.Collections.Specialized
Otros recursos
Matrices en Visual Basic
Pág 61

Las colecciones proporcionan un método ideal para administrar diferentes objetos. Puede agregar y quitar
objetos de una colección, recuperarlos basándose en un índice o en una clave y utilizar Instrucción For
Each...Next (Visual Basic) para recorrer en iteración los elementos de la colección.
Colecciones de tipo no seguras
No obstante, la propia flexibilidad de las colecciones puede socavar la solidez de las clases. Por ejemplo, la
colección proporcionada por Visual Basic almacena todos sus elementos como tipo Object, por lo que puede
agregar un elemento de cualquier tipo de datos. No hay ningún método de protección contra los tipos de
datos impropios que se agregan y cuando tiene acceso a un elemento, debe convertirlo de Object en el tipo
de datos deseado.
Colecciones especializadas
.NET Framework proporciona varias alternativas a la colección Visual Basic. El espacio de nombres
System.Collections contiene clases de colección con una funcionalidad específica, como una cola o una lista
ordenada, y el espacio de nombres System.Collections.Specialized contiene clases de colección de naturaleza
especializada, como HybridDictionary.
Colecciones de tipo seguras
Para evitar los inconvenientes de los elementos de tipo Object, puede utilizar las colecciones genéricas del
espacio de nombres System.Collections.Generic. Estas colecciones proporcionan la seguridad de tipos y le
permiten limitar los elementos de una colección a sólo un tipo de datos específico.
Enfoques sobre el uso de colecciones
Existen tres enfoques generales que se pueden seguir para implementar la administración de objetos
mediante colecciones. Considere una aplicación que define una clase widgetRepository que organiza y
expone los objetos widget para los componentes de cliente. Para implementar widgetRepository con una
colección, puede utilizar una de las estrategias siguientes.
 Utilice una clase de colección. En la clase widgetRepository, declare una variable
widgetsColl como una instancia de Clase de colección de Visual Basic o de una de las clases de
los espacios de nombres System.Collections, System.Collections.Generic o
System.Collections.Specialized. Haga que la variable sea pública y utilice la palabra clave New
(Visual Basic) para crear una instancia de la colección. Para obtener más información, consulte
Cómo: Definir colecciones en clases propias.
 Herede una clase base de colección. Implemente una clase widgetsColl propia mediante
herencia de la clase CollectionBase. En la clase widgetRepository, defina una instancia de la clase
widgetsColl y una propiedad que devuelva esta instancia. Para obtener más información, vea
Cómo: Definir colecciones en clases propias.
 Escriba la colección. Implemente la funcionalidad de colección en la clase widgetRepository
escribiendo clases y procedimientos adecuados. Este enfoque es especialmente útil si desea
disponer de la funcionalidad de colección en la clase pero no puede heredar de ninguna de las
clases de colección existentes. Por ejemplo, esto puede ser posible en el caso poco frecuente de que
su clase necesitara heredar de una clase que no fuera una clase de colección. Como no puede
heredar de más de una clase, tendría que definir e implementar miembros de colección.
Vea también
Conceptos
Referencia
Pág 62
System.Collections

Una colección es una forma de agrupar un conjunto de elementos relacionados. Existen muchos tipos
diferentes de colecciones. Las colecciones predefinidas se utilizan en aplicaciones de Visual Basic para
muchos propósitos, por ejemplo Control..::.ControlCollection en Form, devuelto por la propiedad Controls del
formulario. También puede crear sus propias colecciones para organizar y manipular los objetos.
Las colecciones son un buen método para hacer un seguimiento de los objetos que una aplicación puede
necesitar crear o destruir dinámicamente. El fragmento de código siguiente muestra cómo se puede utilizar
Agregar método de un objeto de colección de Visual Basic para mantener una lista de objetos widget que ha
creado el usuario.
Copiar código
' Declare and create the Collection object.
Public widgetColl As New Microsoft.VisualBasic.Collection()
' Create a new widget and add it to the widgetColl collection.
Private Sub makeAWidget()
Dim tempWidget As New widget()
widgetColl.Add(tempWidget)
End Sub
En el ejemplo anterior, la colección widgetColl organiza y expone todos los objetos widget creados a
través del procedimiento makeAWidget. Se pueden recuperar referencias a objetos para cada widget a
través del índice de la colección. El tamaño de la colección se ajusta automáticamente cada vez que se
agrega un nuevo objeto widget. Puede utilizar Instrucción For Each...Next (Visual Basic) para repetir la
acción a lo largo de la colección. Si desea asignar al objeto widget una clave mediante la que se pueda
recuperar dicho objeto, puede proporcionar una cadena de texto como el segundo parámetro del método
Add.
El objeto Collection de Visual Basic almacena todos sus elementos como tipo Object, por lo que puede
agregar un elemento de cualquier tipo de datos. No hay ningún método de protección contra los tipos de
datos inadecuados que se agreguen. Para evitar esta limitación, puede utilizar las colecciones genéricas del
espacio de nombres System.Collections.Generic. Para obtener más información, consulte Cómo: Crear una
colección de objetos.
Crear y destruir un objeto de colección
La palabra clave New (Visual Basic) en la declaración de la variable widgetColl produce un objeto
Collection que se va a crear cuando el control pasa a la instrucción de declaración. Como Collection es una
clase y no un tipo de datos, debe crear una instancia de la misma y mantener una referencia a esa instancia
en una variable. Esta instancia es un objeto de colección de Visual Basic.
Como cualquier otro objeto, un objeto Collection se marca para la recolección de elementos no utilizados
(GC) cuando la última variable que contiene una referencia a él se establece en Nothing (Visual Basic) o sale
del ámbito. Todas las referencias a objetos que contiene se liberan cuando la reclama una recolección de
elementos no utilizados. Por este motivo, la variable widgetColl del ejemplo anterior se declara en la clase
principal para que exista a lo largo de la vida del programa.
Pág 63
Una colección mantiene las referencias a los objetos que controla pero no contiene los objetos en sí. Al
destruir un objeto Collection, por consiguiente, no se destruyen los objetos que controla. Cada objeto
individual que había sido un elemento de la colección continúa existiendo hasta que se marque
individualmente para la recolección de elementos no utilizados.
Trabajar con elementos
Los servicios básicos de agregar, eliminar y recuperar elementos de una colección dependen de claves e
índices. Una clave es un valor String. Podría ser un nombre, un número de permiso de conducción, un
número de teléfono o simplemente un entero convertido en una cadena. El método Add le permite asociar
una clave a un elemento, tal como se describe en Cómo: Agregar, eliminar y recuperar los elementos de una
colección.
Un índice en la clase Collection es un entero entre 1 y el número de elementos de la colección. Count
(Propiedad, objeto Collection) devuelve el número actual de elementos. Se puede controlar el valor inicial del
índice de un elemento mediante los parámetros Before y After, cuando llama a Add, pero su valor puede
cambiar cuando se agregan o eliminan otros elementos. Para obtener más información, consulte Add
(Método, objeto Collection).
Puede quitar un elemento único de una colección pasando su clave o su índice a Remove (Método, objeto
Collection). Puede vaciar una colección y quitar todos los elementos con Clear (Método, objeto Collection).
Tener acceso a elementos
Puede pasar un valor clave a Contains (Método, objeto Collection) para probar si una colección contiene un
elemento con esa clave. Puede recuperar un elemento pasando su clave o su índice a Item (Propiedad,
objeto Collection).
Puede utilizar valores de índice y la propiedad Item para recorrer en iteración los elementos de una colección
o puede utilizar Instrucción For Each...Next (Visual Basic). El ejemplo siguiente muestra dos maneras de
aplicar una subida del 10 por ciento a todos los empleados de una colección de objetos employee,
suponiendo que la variable employeesColl contiene una referencia a un objeto Collection.
Copiar código
Option Strict On
' The following alternative uses the Count and Item properties.
Dim emp As employee
For counter As Integer = 1 To employeesColl.Count
emp = CType(employeesColl.Item(counter), employee)
emp.payRate *= 1.1
Next counter
' The following alternative uses the For Each...Next statements.
For Each emp As employee In employeesColl
emp.payRate *= 1.1
Next emp
Sin embargo, si ha agregado uno o más elementos a employeesColl que no son de tipo employee, el bucle
For Each produce una excepción ArgumentException en tiempo de ejecución.
Tipo de datos de elementos
Un objeto de colección de Visual Basic almacena los elementos con el tipo de datos Object. Por consiguiente,
el intervalo de tipos de datos que puede agregar a un objeto Collection es igual al intervalo de tipos de datos
que puede almacenar en una variable Object. Ésta incluye tipos de datos estándar, objetos y matrices, así
como estructuras definidas por el usuario e instancias de clase.
Pág 64
Como el objeto Collection almacena los elementos como Object, la propiedad Item devuelve un valor Object.
Para utilizar el elemento en su código, debe convertir normalmente de Object al tipo de datos en tiempo de
ejecución del elemento. La manera de hacerlo depende de la configuración del modificador de comprobación
de tipos en Option Strict (Instrucción).
Conversión implícita desde el objeto
Si Option Strict es Off, puede convertir un elemento de Collection implícitamente a su tipo de datos
adecuado, tal como se muestra en el ejemplo siguiente.
Copiar código
Option Strict Off
Dim sampleColl As New Microsoft.VisualBasic.Collection()
Dim sampleString As String = "This is a string"
Dim aString As String
sampleColl.Add(sampleString)
' The following statements convert the collection item to a string.
Try
aString = sampleColl.Item(1)
Catch ex As Exception
' Insert code to run if the collection item cannot be converted to
String.
End Try
Conversión explícita desde el objeto
Si Option Strict es On, debe convertir explícitamente desde Object al tipo de datos en tiempo de ejecución
del elemento. Para obtener un elemento de Item de esta manera, puede utilizar CType (Función) para
realizar la conversión, tal como se muestra en el ejemplo siguiente.
Copiar código
Option Strict On
Dim sampleColl As New Microsoft.VisualBasic.Collection()
Dim sampleString As String = "This is a string"
sampleColl.Add(sampleString)
' The following statements convert the collection item to a string.
Try
aString = CType(sampleColl.Item(1), String)
' Insert code to run if the collection item cannot be converted to
String.
End Try
Servicios adicionales
Los métodos y propiedades del objeto Collection proporcionan solamente los servicios más básicos para
colecciones. Por ejemplo, el método Add no puede comprobar el tipo de un elemento que se agrega a una
colección, comprobación que puede resultar deseable para asegurarnos de que la colección contiene
únicamente una clase de elementos. Si puede garantizar esto en el método Add, tiene una colección con
Pág 65
establecimiento inflexible de tipos y no tiene que convertir el valor devuelto de la propiedad Item a su tipo
de datos en tiempo de ejecución. Esto mejora el rendimiento.
Puede proporcionar una funcionalidad más robusta (y propiedades, métodos y eventos adicionales) creando
su propia clase de colección, tal como se describe en Cómo: Definir colecciones en clases propias.
Vea también
Conceptos
Colecciones como alternativa a las matrices
Referencia
Collection (Objeto, Visual Basic)
Cómo: Definir colecciones en clases propias

Puede agregar una colección a una de sus clases para administrar los grupos de objetos que utiliza su clase.
La forma más sencilla de hacerlo consiste en agregar una variable pública de tipo Collection a la clase.
Considere una clase hipotética denominada widgetRepository que administra y expone objetos widget.
Podría crear una variable widgetColl para hacer referencia a una colección widget, tal como se describe
en el procedimiento siguiente.
Definir una colección simple
Para definir una colección simple en una clase

 Cree una variable pública para que actúe como una colección para sus objetos.
Copiar código
Public Class widgetRepository
' Insert code to implement additional functionality.
End Class
La clase widgetRepository tiene ahora una colección pública a la que se pueden agregar objetos
widget. Puede utilizar Instrucción For Each...Next (Visual Basic) para procesar los elementos de
colección, como muestra el código siguiente.
Copiar código
For Each aWidget As widget In widgetColl
' Insert code to process widgetColl elements
Next aWidget
La colección widgetColl definida en el ejemplo anterior no es con establecimiento inflexible de
tipos, lo que significa que puede agregar cualquier tipo de objeto, no sólo objetos widget. Esto
puede conducir a problemas de seguridad de tipos. Por ejemplo, suponga que agrega String a la
colección, como en el código siguiente.
Copiar código
Dim notWidget As String = "This is not a widget object!"
widgetColl.Add(notWidget)
Pág 66
Si hace esto, el bucle For Each del procedimiento anterior produce una excepción
ArgumentException en tiempo de ejecución porque un elemento de la colección no es de tipo
widget.
Se recomienda definir una clase genérica cuando se desea garantizar la seguridad de tipos. Para
obtener más información y un ejemplo, consulte Cómo: Definir colecciones con seguridad de tipos.
Vea también
Tareas
Cómo: Definir colecciones con seguridad de tipos
Conceptos
Tipos genéricos en Visual Basic
Referencia
Option Strict (Instrucción)
Cómo: Definir colecciones con seguridad de tipos

Puede definir y crear una colección utilizando la clase Collection proporcionada por Visual Basic, como
muestra el ejemplo siguiente.
Visual Basic
Copiar código
Public Class widgetRepository
' Insert code to implement additional functionality.
End Class
Sin embargo, esta colección widgetColl no dispone de establecimiento inflexible de tipos. En ella puede
agregar cualquier tipo de elemento, no sólo objetos widget. Cuando recupera un elemento, puede que deba
intentar convertirlo en widget. Esto puede conducir a problemas de seguridad de tipos. Por ejemplo,
suponga que agrega un objeto tipo String a la colección con el código siguiente.
Visual Basic
Copiar código
Dim notWidget As String = "This is not a widget object!"
widgetColl.Add(notWidget)
En este caso, un intento posterior de recuperar dicho elemento produce una excepción ArgumentException
en tiempo de ejecución ya que el elemento de la colección no es del tipo widget.
Protección contra los problemas de seguridad de tipos
Recomendamos que aumente la seguridad de tipos definiendo una clase genérica. Así se exige el
establecimiento inflexible de tipos se consigue flexibilidad en el tipo de datos concreto con el que trabaja.
Para obtener más información, vea Tipos genéricos en Visual Basic.
Pág 67
Para definir una colección con seguridad de tipos en una clase

 Utilice una de las clases genéricas en el espacio de nombres System.Collections.Generic, por
ejemplo List<(Of <(T>)>), para la clase de colección. A continuación, puede crear una colección
que se restringe a los miembros widget. El ejemplo siguiente muestra cómo se podría modificar la
declaración del ejemplo anterior para crear una colección genérica.
Visual Basic
Copiar código
Public widgetColl As New System.Collections.Generic.List(Of widget)
En este caso, el establecimiento inflexible de tipos sólo permite agregar elementos widget a la
colección y cada elemento que se recupera por medio de la propiedad Item es un objeto widget.
Debido al establecimiento inflexible de tipos, el código de recuperación también puede utilizar todas
las propiedades y los métodos expuestos por widget.
O bien
 Cree su propia clase de colección sin utilizar ninguna clase predefinida. Restrinja el método Add
para que sólo acepte objetos widget e implemente la propiedad Item con un tipo de valor devuelto
de widget. Para obtener más información, vea Cómo: Definir colecciones con seguridad de tipos.
Si Item devuelve elementos de tipo Object, sólo tendría acceso explícito a las propiedades y
métodos definidos en la clase Object. Para tener acceso a los miembros de widget, debería activar
Option Strict Off o utilizar CType (Función) para convertir de forma explícita el elemento devuelto a
widget, como en el código siguiente.
Visual Basic
Copiar código
Dim nextWidget As widget
Try
nextWidget = CType(widgetColl.Item(1), widget)
' Insert code to run if the collection item is not a widget.
End Try
En cualquiera de los casos, si utiliza los elementos Object de esta manera, Visual Basic emplea el
enlace en tiempo de ejecución, lo que reduce el rendimiento.
Tenga en cuenta que la clase Collection de Visual Basic acepta y devuelve elementos Object, por lo
que también tiene las desventajas de los tipos flexibles y el enlace en tiempo de ejecución.
Vea también
Conceptos
Tipos genéricos en Visual Basic
Referencia
System.Collections
Pág 68
Contraer todo
Filtro de idioma : Todos

Como ocurre con cualquier objeto, declare una variable para contener el objeto y, a continuación, cree el
objeto de la colección y asígnelo a la variable.
Para un objeto de colección, puede utilizar Clase de colección de Visual Basic o una clase de colección de
.NET Framework. En particular, puede crear una colección genérica utilizando una de las clases en el espacio
de nombres System.Collections.Generic. Una colección genérica es útil cuando todos los elementos de la
colección tienen el mismo tipo de datos. Las colecciones genéricas cumplen el establecimiento inflexible de
tipos al permitir agregar sólo el tipo de datos deseado. Para obtener más información, consulte Cómo:
Definir colecciones con seguridad de tipos.
Cuando se crea el objeto de colección, puede agregar y quitar elementos y elementos de acceso de la
colección.
A continuación, se muestran dos ejemplos sobre cómo crear colecciones. Cada colección contiene elementos
String y asocia una clave String a cada elemento. Los dos primeros procedimientos crean una colección
mediante la clase de colección de Visual Basic. Los dos últimos procedimientos crean una colección mediante
una clase de colección genérica de .NET Framework.
Crear una colección mediante la clase de colección de Visual Basic

1. Declare y cree una variable de Visual BasicCollection, tal como se muestra en el ejemplo siguiente.
Copiar código
Dim sampleVisualBasicColl As New Microsoft.VisualBasic.Collection()
La colección de sampleVisualBasicColl puede aceptar elementos de cualquier tipo de datos.
2. Utilice Add (Método, objeto Collection) para agregar elementos a la colección. El ejemplo siguiente
crea cuatro elementos String y los agrega a la colección. Crea un valor String único como clave para
cada nuevo elemento y lo pasa al método Add.
Copiar código
Dim item1, item2, item3, item4 As String
item1 = "Items"
item2 = "In"
item3 = "A"
item4 = "Collection"
sampleVisualBasicColl.Add(item1, "firstkey")
Pág 69
sampleVisualBasicColl.Add(item2, "secondkey")
sampleVisualBasicColl.Add(item3, "thirdkey")
sampleVisualBasicColl.Add(item4, "fourthkey")
El argumento Key es opcional en una colección de Visual Basic.
3. Si desea quitar un elemento de la colección, puede utilizar Remove (Método, objeto Collection)
identificando el elemento por su índice posicional o por su clave opcional. Esto se ilustra en el
siguiente ejemplo:
Copiar código
' Remove the first element of the Visual Basic collection.
sampleVisualBasicColl.Remove(1)
' Remove the element with the key "secondkey".
sampleVisualBasicColl.Remove("secondkey")
Tenga en cuenta que al quitar un elemento de Visual BasicCollection, los valores del índice se
numeran desde 1 hasta el valor de Count (Propiedad, objeto Collection).
Para utilizar For Each...Next para procesar los elementos de la colección de Visual
Basic
1. Declare una variable del tipo almacenado en la colección. Para obtener el ejemplo anterior, declare
una variable de tipo String, tal como muestra el ejemplo siguiente.
Copiar código
' Insert code from the preceding example.
2. Utilice Instrucción For Each...Next (Visual Basic) para examinar cada elemento de la colección. El
ejemplo siguiente busca una cadena determinada y la muestra si la encuentra.
Copiar código
For Each aString in sampleVisualBasicColl
If aString = "Collection" Then
MsgBox(aString)
End If
Next aString
Para crear una colección mediante una clase de colección genérica

1. Declare y cree una variable de .NET FrameworkSystem.Collections.Generic.Dictionary(TKey,
TValue), tal como se muestra en el ejemplo siguiente.
Copiar código
Dim sampleGenericColl As New
System.Collections.Generic.Dictionary(Of String, String)
La variable sampleGenericColl contiene una colección de tipo seguro que sólo acepta elementos y
claves de tipo String.
Pág 70
2. Utilice el método Dictionary(TKey, TValue).Add para agregar elementos a la colección. El ejemplo

siguiente crea cuatro elementos String y los agrega a la colección. Crea un valor String único como
clave para cada nuevo elemento y lo pasa al método Add.
Copiar código
Dim item1, item2, item3, item4 As String
item1 = "Items"
item2 = "In"
item3 = "A"
item4 = "Collection"
sampleGenericColl.Add("firstkey", item1)
sampleGenericColl.Add("secondkey", item2)
sampleGenericColl.Add("thirdkey", item3)
sampleGenericColl.Add("fourthkey", item4)
Se requiere el argumento Key en esta colección genérica.
3. Para quitar un elemento de la colección, utilice el método IDictionary(TKey, TValue).Remove. Debe
proporcionar la clave para identificar el elemento que se va a quitar. Esto se ilustra en el siguiente
ejemplo:
Copiar código
If Not sampleGenericColl.Remove("thirdkey")
' Insert code to handle "thirdkey" not found in collection.
End If
Puede utilizar una instrucción For Each...Next para recorrer en iteración y procesar los elementos de
una colección, como muestra el procedimiento siguiente.
Para utilizar For Each...Next para procesar los elementos de la colección genérica
1. Declare una variable del tipo almacenado en la colección. Para obtener el ejemplo anterior, declare
una variable de tipo String, tal como muestra el ejemplo siguiente.
Copiar código
' Insert code from the preceding example.
Dim aPair As KeyValuePair(Of String, String)
2. Utilice Instrucción For Each...Next (Visual Basic) para examinar cada elemento de la colección. El
ejemplo siguiente busca una cadena determinada y la muestra si la encuentra.
Copiar código
For Each aPair In sampleGenericColl
If aPair.Value = "Items" Then
MsgBox(aPair.Key & " -- " & aPair.Value)
End If
Next aPair
Vea también
Tareas
Pág 71

Conceptos
Referencia
System.Collections
Collection (Objeto, Visual Basic)

Un objeto es un tipo de referencia. Para declarar y utilizar una matriz de un tipo de referencia se procede del
mismo modo que para declarar y utilizar una matriz de cualquier tipo de datos. Los elementos de una matriz
de tipo objeto pueden recuperarse mediante su índice y manipularse como cualquier otro objeto del tipo
determinado.
Las matrices también tienen funcionalidad integrada para buscar y ordenar, a la que se puede tener acceso a
través la variable de matriz. Para obtener más información acerca de estos métodos, consulte Array.
Para crear una matriz de objetos

1. Declare la matriz como se muestra en el ejemplo siguiente. Debido a que las matrices se basan en
cero, contienen un elemento más que el límite superior que se declara.
Copiar código
Dim x(10) As widget
' x now contains 11 elements of type widget, x(0) through x(10).
2. Cree los elementos de la matriz o asigne a cada elemento una referencia a un objeto ya existente.
En el siguiente ejemplo se muestra cómo.
Copiar código
' Create each element of an array by using a loop.
For q As Integer = 0 To 10
x(q) = New widget()
Next q
' Assign a reference to an existing object to two array elements.
Dim specialWidget As New widget()
x(0) = specialWidget
x(1) = specialWidget
Observe que puede asignar referencias al mismo objeto a distintos elementos de la matriz.
Vea también
Tareas
Conceptos
Tipos de valores y tipos de referencia
Pág 72
Otros recursos
Matrices en Visual Basic
Contraer todo
Cómo: Agregar, eliminar y recuperar los elementos de una

colección
La clase Collection de Visual Basic contiene funcionalidad integrada, que permite agregar, eliminar y
recuperar elementos.
 Es posible que desee agregar un elemento a una colección en cuanto se crea o se obtiene el
elemento, por ejemplo un nuevo cliente.
 Puede desear eliminar un elemento de una colección cuando ya no pertenece a la colección, por
ejemplo cuando un empleado deja su compañía.
 Es posible que desee recuperar un elemento de una colección para editar su contenido, por ejemplo
cambiar el número de teléfono de un estudiante.
Nota:
Los objetos Collection actualizan sus números de índice numéricos automáticamente cuando
agrega y elimina elementos. Por ello, el índice numérico de un elemento determinado puede
cambiar a menudo. Por ello, cuando guarde un valor de índice numérico, no espere recuperar el
mismo elemento posteriormente en el programa. Para este propósito utilice claves.
Para agregar un elemento a una colección

 Utilice Add (Método, objeto Collection) y especifique el elemento por su Key.
object.Add(Item, Key [, {Before | After}])
Por ejemplo, para agregar un objeto de orden de trabajo a una colección de órdenes de trabajo
utilizando como clave la propiedad ID de la orden de trabajo, puede realizar la siguiente llamada:
Copiar código
workOrders.Add(woNew, woNew.ID)
La llamada anterior supone que la propiedad ID es una cadena. Si es un número (por ejemplo, un
entero Long ), utilice su método ToString para convertirlo en el valor String necesario para el
argumento Key.
Copiar código
workOrders.Add(woNew, woNew.ID.ToString())
El uso de una clave es opcional. Si no desea asociar una clave al objeto de su colección, puede
agregarlo sin una clave.
Copiar código
Pág 73
workOrders.Add(woNew)
Puede utilizar los argumentos Before y After para mantener una colección ordenada de objetos. El
miembro que se agrega se coloca en la colección antes o después del miembro identificado por el
argumento Before o After respectivamente. Por ejemplo, si estable Before igual a 1, se inserta un
elemento al principio de la colección porque los objetos Collection están basados en 1.
Copiar código
workOrders.Add(woNew, woNew.ID, 1)
De forma similar, el argumento After agrega un elemento después del índice especificado. El
siguiente ejemplo agrega un tercer elemento.
Copiar código
workOrders.Add(woNew, woNew.ID,,2)
Se puede especificar un valor para Before o para After, pero no para ambos.
Para eliminar un elemento de una colección

 Utilice Remove (Método, objeto Collection) y especifique el elemento por su Index o su Key.
object.Remove({Index | Key})
El argumento Index es la posición del elemento que desea eliminar. El argumento Key es la misma
cadena que ha utilizado para agregar el elemento a la colección. Si la clave del tercer elemento de
una colección es "W017493", puede utilizar cualquiera de las dos instrucciones siguientes para
eliminarlo.
Copiar código
workOrders.Remove(3)
workOrders.Remove("W017493")
Para eliminar todos los elementos de una colección

 Use Clear (Método, objeto Collection).
object.Clear()
El método Clear vacía la colección.
Para recuperar un elemento de una colección

1. Utilice Item (Propiedad, objeto Collection) y especifique el elemento por su Index o su Key.
variable = object.Item({Index | Key})
Igual que con el método Remove, el argumento Index es la posición del elemento en la colección y
el argumento Key es la cadena utilizada al agregar el elemento. Con el mismo ejemplo del método
Remove, cualquiera de las instrucciones siguientes recupera el tercer elemento de la colección:
Copiar código
woCurrent = workOrders.Item(3)
woCurrent = workOrders.Item("W017493")
Nota:
Si utiliza números como claves, debe utilizar sus métodos ToString para convertirlos en las
Pág 74
cadenas antes de pasarlos al método Add o Remove o a la propiedad Item. Un objeto de Visual
BasicCollection supone siempre que un número es un índice, en vez de una cadena de clave.
2. Si conoce la clave en el tiempo de compilación, puede utilizar alternativamente el operador (!) de

acceso a diccionario para tener acceso a un elemento de la colección sin incluir la clave entre
comillas o paréntesis. La llamada anterior se puede escribir del modo siguiente.
Copiar código
woCurrent = workOrders!W017493
Vea también
Conceptos
Colecciones como alternativa a las matrices
Referencia
Collection (Miembros del objeto)
Add (Método, objeto Collection)
Remove (Método, objeto Collection)
Clear (Método, objeto Collection)
Item (Propiedad, objeto Collection)
Cómo: Recorrer en iteración una colección de Visual Basic

Puede utilizar un bucle For Each para recorrer en iteración los elementos de una colección.
Ejemplo
El ejemplo siguiente utiliza Instrucción For Each...Next (Visual Basic) para tener acceso a todos los
elementos de una colección.
Copiar código
Dim testCollection As New Microsoft.VisualBasic.Collection()
' The collection is empty until you add one or more items to it.
For Each collectionItem As Object In testCollection
' Perform desired processing on each item.
Next collectionItem
Compilar el código
Este ejemplo necesita:
 Obtener acceso al espacio de nombres System.
Vea también
Tareas
Conceptos
Referencia
Instrucción For Each...Next (Visual Basic)
Contraer todo
Pág 75

Solucionar problemas de colecciones

Esta página muestra algunos problemas comunes que pueden aparecer al trabajar con colecciones.
Utilizar el tipo de colección equivocado
Hay varios tipos de colecciones disponibles para los desarrolladores de Visual Basic: la clase Collection de
Visual Basic y las clases de colección proporcionadas por .NET Framework. Estas clases no son compatibles
entre sí. Esto significa que, si declara una variable para que sea de un tipo de colección, no puede asignar un
objeto de otro tipo a esa variable. Además, sólo puede tener acceso a los métodos y propiedades del tipo de
colección que ha declarado.
Las diferencias principales entre Visual Basic y clases de colección de .NET Framework incluyen lo siguiente:
 Base de índice. Las colecciones de .NET Framework están basadas en cero, mientras que las
colecciones de Visual Basic están basadas en uno. Esto significa que los elementos de una colección
de Visual Basic tienen valores de índice comprendidos entre 1 y el valor de Count (Propiedad, objeto
Collection), mientras que los elementos de una colección de .NET Framework tienen valores de
índice que van desde 0 hasta uno menos que el valor de la propiedad Count de la colección.
 Tipo de elemento. La colección de Visual Basic admite elementos de tipo Object, que no posee
seguridad de tipos porque puede agregar un elemento de cualquier tipo de datos. Esto
normalmente produce una degradación del rendimiento porque el compilador debe aplicar
conversiones boxing y unboxing a los elementos para convertirlos al Object (Tipo de datos) y desde
él. Algunas de las colecciones de .NET Framework también tienen elementos del tipo Object, pero
muchas otras tienen establecimiento inflexible de tipos, que significa que admiten elementos de un
tipo específico, lo cual les atribuye seguridad de tipos y normalmente permite conseguir un
rendimiento óptimo.
 Elementos con clave. La colección de Visual Basic permite especificar una clave cuando se agrega
un elemento a ella. La clave es un valor String único que se puede utilizar después para tener
acceso a ese elemento concreto. Las colecciones .NET Framework varían con respecto a las claves.
Algunas admiten claves y otras no.
Los espacios de nombres que contienen las distintas definiciones de clase de colección son los siguientes:
 Microsoft.VisualBasic — clase Collection de Visual Basic
 System.Collections — clases de colección específicas como listas, colas, matrices de bits, tablas de
hash y diccionarios
 System.Collections.Generic — clases de colección genéricas, que permiten crear colecciones con
establecimiento inflexible de tipos y especificar el tipo de datos de los elementos cuando se crean
 System.Collections.Specialized — clases de colección especializadas con establecimiento inflexible
de tipos, como diccionarios híbridos y de listas vinculadas, colecciones de bits-vectores y nombres-
objetos, y colecciones sólo de cadenas
Pág 76
Enfoque correcto
Determine qué tipo de colección es más adecuado para sus necesidades. Declare su variable de colección
para que sea de ese tipo y asegúrese de crear un objeto de ese mismo tipo. Utilice la calificación completa
para asegurarse de que está especificando el tipo de colección deseado. El ejemplo siguiente muestra dos
declaraciones con calificación completa.
Visual Basic
Copiar código
Dim customers As New Microsoft.VisualBasic.Collection()
Dim stringQueue As New System.Collections.Generic.Queue(Of String)
Una vez creada una colección de un tipo específico, asegúrese de utilizar sólo los métodos y propiedades
definidos en ese tipo. Establezca Option Strict On para detectar cualquier asignación incorrecta de objeto o
acceso a miembro en tiempo de compilación.
Vea también
Conceptos
Referencia

Un evento es un mensaje que envía un objeto anunciando que ha sucedido algo. Los eventos se
implementan mediante delegados, una forma de puntero de función orientado a objetos que permite invocar
una función indirectamente mediante una referencia a la función.
En esta sección
Eventos y controladores de eventos
Proporciona información general sobre los eventos, los controladores de eventos y terminología
relacionada.
WithEvents y la cláusula Handles
Muestra cómo utilizar la palabra clave WithEvents y la cláusula Handles para asociar un evento a
un controlador de eventos.
AddHandler y RemoveHandler
Muestra cómo utilizar las instrucciones AddHandler y RemoveHandler para asociar de forma
dinámica un evento a un controlador de eventos.
Describe el proceso para definir eventos.
Cómo: Crear controladores de eventos en el Editor de código de Visual Basic
Proporciona instrucciones para escribir código que responda a eventos en el Editor de código de
Visual Basic.
Cómo: Provocar un evento (Visual Basic)
Muestra cómo definir un evento y utiliza la instrucción RaiseEvent para hacer que se produzca el
evento.
Cómo: Crear un evento y un controlador (Visual Basic)
Pág 77
Muestra cómo definir un evento y un controlador de eventos y cómo utilizar la instrucción

AddHandler para asociarlos.
Cómo: Escribir controladores de eventos
Muestra cómo crear controladores de eventos mediante la cláusula Handles o la instrucción
AddHandler.
Cómo: Controlar eventos en Visual Basic
Define una clase que provoca un evento al llamar al método CauseEvent.
Tutorial: Declarar y provocar eventos
Proporciona una descripción paso a paso de cómo declarar y provocar los eventos de una clase.
Tutorial: Controlar eventos
Muestra cómo escribir un procedimiento controlador de eventos.
Cómo: Declarar eventos que evitan bloqueos
Muestra cómo definir un evento personalizado que permite llamar a sus controladores de eventos
de forma asincrónica.
Cómo: Declarar eventos que evitan que se pierda memoria
Muestra cómo definir un evento personalizado que sólo utiliza la memoria cuando se controla el
evento.
Solucionar problemas de controladores de eventos heredados en Visual Basic
Enumera problemas comunes que surgen con controladores de eventos en componentes heredados.
Proporciona información general sobre los delegados en Visual Basic.
Controlar y provocar eventos
Proporciona información general sobre el modelo de eventos de .NET Framework.
Crear controladores de eventos en formularios Windows Forms
Describe cómo trabajar con eventos asociados a objetos de formularios Windows Forms.

A pesar de que puede visualizar un proyecto de Visual Studio como una serie de procedimientos que se
ejecutan consecutivamente, en realidad la mayoría de los programas están dirigidos por eventos, es decir, el
flujo de ejecución está determinado por elementos externos denominados eventos.
Un evento es una señal que comunica a una aplicación que ha sucedido algo importante. Por ejemplo,
cuando un usuario hace clic en un control de un formulario, el formulario puede provocar un evento Click y
llamar a un procedimiento que controla el evento. Los eventos también permiten que las tareas separadas se
comuniquen. Suponga, por ejemplo, que una aplicación realiza una tarea de ordenación independientemente
de la aplicación principal. Si un usuario cancela la ordenación, la aplicación puede enviar un evento de
cancelación que ordene la detención del proceso de ordenación.
Conceptos y términos de los eventos
Esta sección describe los términos y conceptos que se utilizan con eventos en Visual Basic.
Declarar eventos
Los eventos se declaran en clases, estructuras, módulos e interfaces mediante la palabra clave Event, como
se muestra en el siguiente ejemplo:
Visual Basic
Copiar código
Event AnEvent(ByVal EventNumber As Integer)
Pág 78
Producir eventos
Un evento es como un mensaje que anuncia que ha pasado algo importante. A la acción de difundir el
mensaje se le llama producir el evento. En Visual Basic, los eventos se producen con la instrucción
RaiseEvent, como en el ejemplo siguiente:
Visual Basic
Copiar código
RaiseEvent AnEvent(EventNumber)
Los eventos se deben provocar dentro del ámbito de la clase, módulo o estructura donde se declaran. Por
ejemplo, una clase derivada no puede producir eventos heredados de una clase base.
Remitentes de eventos
Cualquier objeto capaz de producir un evento es un remitente de eventos, y también recibe el nombre de
origen de eventos. Los formularios, controles y objetos definidos por el usuario son ejemplos de remitentes
de eventos.
Controladores de eventos
Los controladores de eventos son procedimientos llamados cuando se produce un evento correspondiente.
Puede utilizar cualquier subrutina válida con una firma coincidente como controlador de eventos. No
obstante, no puede utilizar una función como controlador de eventos, porque no puede devolver un valor al
origen del evento.
Visual Basic utiliza una convención de nomenclatura estándar para controladores de eventos que combina el
nombre del remitente del evento, un signo de subrayado y el nombre del evento. Por ejemplo, el evento
Click de un botón denominado button1 recibiría el nombre de Sub button1_Click.
Nota:
Es recomendable utilizar esta convención de nomenclatura al definir controladores de eventos para

sus propios eventos, pero no es estrictamente necesario; puede utilizar cualquier nombre de
subrutina válido.
Asociar eventos a controladores de eventos

Para que un controlador de eventos se pueda utilizar, primero debe asociarse a un evento mediante la
instrucción Handles o AddHandler.
La instrucción WithEvents y la cláusula Handles proporcionan una forma declarativa de especificar
controladores de eventos. Los eventos provocados por un objeto declarado con WithEvents los puede
controlar cualquier subrutina con una cláusula Handles que dé nombre a este evento. Aunque la cláusula
Handles es la forma estándar de asociar un evento a un controlador de eventos, está limitada a asociar
eventos a controladores de eventos en tiempo de compilación.
Las instrucciones AddHandler y RemoveHandler son más flexibles que la cláusula Handles. Le permiten
conectar y desconectar de forma dinámica los eventos con uno o varios controladores de eventos en tiempo
de ejecución, y no requieren que declare variables de objeto mediante WithEvents. Sin embargo, hay
algunas restricciones en el uso de WithEvents. Para obtener más información, vea WithEvents y la cláusula
Handles.
En algunos casos, como con eventos asociados a formularios o controles, Visual Basic finaliza
automáticamente un controlador de eventos vacío y lo asocia con un evento. Por ejemplo, al hacer doble clic
en un botón de comando en un formulario en modo de diseño, Visual Basic crea un controlador de eventos
vacío y una variable WithEvents para el botón de comando, como en el código siguiente:
Visual Basic
Pág 79
Copiar código
Friend WithEvents Button1 As System.Windows.Forms.Button
Protected Sub Button1_Click(ByVal sender As System.Object, _
End Sub
Vea también
Tareas
Conceptos
Referencia
Handles
AddHandler (Instrucción)

La instrucción WithEvents y la cláusula Handles proporcionan una forma declarativa de especificar
controladores de eventos. Los eventos provocados por un objeto declarado con la palabra clave WithEvents
pueden controlarse mediante cualquier procedimiento con una instrucción Handles para ese evento, tal y
como se muestra en el ejemplo siguiente:
Visual Basic
Copiar código
' Declare a WithEvents variable.
Dim WithEvents EClass As New EventClass
' Call the method that raises the object's events.

Sub TestEvents()
EClass.RaiseEvents()
End Sub
' Declare an event handler that handles multiple events.

Sub EClass_EventHandler() Handles EClass.XEvent, EClass.YEvent
MsgBox("Received Event.")
End Sub
Class EventClass
Public Event XEvent()
Public Event YEvent()
' RaiseEvents raises both events.
Sub RaiseEvents()
Pág 80
RaiseEvent XEvent()
RaiseEvent YEvent()
End Sub
End Class
La instrucción WithEvents y la cláusula Handles son a menudo la mejor opción para los controladores de
eventos, ya que la sintaxis declarativa que utilizan hace que el control de eventos sea más sencillo de
codificar, leer y depurar. No obstante, tenga en cuenta las siguientes limitaciones en la utilización de las
variables WithEvents:
 No se puede utilizar una variable WithEvents como variable de objeto. Es decir, no es posible
declararla como Object; se debe especificar el nombre de clase al declarar la variable.
 Dado que los eventos compartidos no están asociados a instancias de clase, no se puede usar
WithEvents para controlar los eventos mediante declaraciones compartidas. De forma parecida, no
se puede utilizar WithEvents ni Handles para controlar los eventos desde una estructura
Structure. En ambos casos, puede utilizar la instrucción AddHandler para controlar esos eventos.
 No se pueden crear matrices de variables WithEvents.
 Las variables WithEvents permiten que un solo controlador controle uno o más tipos de eventos,
así como que uno o más controladores de eventos controlen el mismo tipo de evento.
Vea también
Conceptos
Referencia
Handles
WithEvents
La instrucción AddHandler se parece a la cláusula Handles en que las dos permiten especificar un
controlador de eventos. Sin embargo, AddHandler, utilizado con RemoveHandler, proporciona más
flexibilidad que la cláusula Handles, lo que permite agregar, quitar y cambiar de forma dinámica el
controlador de errores asociado con un evento. Si desea controlar eventos compartidos o eventos de una
estructura, debe utilizar AddHandler.
AddHandler toma dos argumentos: el nombre de un evento de un remitente de evento, como un control, y
una expresión que evalúa a un delegado. No necesita especificar explícitamente la clase delegada al utilizar
AddHandler, ya que la instrucción AddressOf siempre devuelve una referencia al delegado. El ejemplo
siguiente asocia un controlador de eventos a un evento provocado por un objeto:
Visual Basic
Copiar código
AddHandler Obj.XEvent, AddressOf Me.XEventHandler
RemoveHandler, que desconecta un evento de un controlador de eventos, utiliza la misma sintaxis que
AddHandler. Por ejemplo:
Visual Basic
Copiar código
Pág 81
RemoveHandler Obj.XEvent, AddressOf Me.XEventHandler
Vea también
Tareas
Conceptos
Referencia
Contraer todo

Se agregan eventos a una clase declarándolos con la instrucción Events. La declaración incluye el nombre
del evento y los argumentos que utiliza.
La acción de agregar un evento a una clase determina que un objeto de esta clase puede provocar un evento
específico. Para conseguir que se produzca un evento, se debe utilizar la instrucción RaiseEvent. Puede
utilizar la palabra clave Handles o la instrucción AddHandler para asociar el evento a un procedimiento
controlador de eventos. Los eventos deben producirse dentro del ámbito en el que se han declarado. Por
ejemplo, una clase derivada no puede producir eventos heredados de una clase base.
Nota:
Los eventos no pueden tener valores devueltos, argumentos opcionales o argumentos

ParamArray.
Para agregar un evento a una clase

 En la sección Declaraciones del módulo de clase que define la clase, utilice la instrucción Event para
declarar el evento con cualquier argumento que desee que tenga. Por ejemplo:
Visual Basic
Copiar código
Public Event PercentDone(ByVal Percent As Single, _
ByRef Cancel As Boolean)
Vea también
Tareas
Pág 82

Conceptos
Los delegados y el operador AddressOf
Referencia
RaiseEvent (Instrucción)
Handles
Otros recursos
Polimorfismo
Contraer todo
Cómo: Crear controladores de eventos en el Editor de código

de Visual Basic
El Editor de código de Visual Basic ofrece una forma sencilla de crear controladores de eventos para los
formularios Windows Forms. Aunque no permite conectar varios eventos a un único controlador de eventos
(vea Cómo: Conectar varios eventos con un único controlador de eventos en formularios Windows Forms), sí
ofrece una forma fácil y rápida de crear controladores de eventos mientras se trabaja en el código del
formulario, sin tener que abrirlo en el Diseñador de Windows Forms.
Para crear un controlador de eventos en el Editor de código de Visual Basic

1. En el Editor de código, en la lista desplegable Nombre de clase, elija el formulario o el control para
el que desea crear un controlador de eventos.
2. En la lista Nombre de método, en la parte superior del Editor de código, elija el evento para el que
desea crear un controlador.
Visual Basic creará un controlador de eventos y lo agregará a la clase del formulario.
Vea también
Tareas
Cómo: Crear controladores de eventos con el diseñador
Solucionar problemas de controladores de eventos heredados en Visual Basic
Conceptos
Información general sobre controladores de eventos (Formularios Windows Forms)
Otros recursos
Crear un nuevo formulario Windows Forms
Pág 83

En este ejemplo se define un evento (TimeExpired) y se utiliza la instrucción RaiseEvent para hacer que
se produzca el evento.
Ejemplo
Visual Basic
Copiar código
Public Event TimeExpired(ByVal Status As String)
Public Sub RaiseTimeExpiredEvent()
RaiseEvent TimeExpired("Your time has run out")
End Sub
Este ejemplo de código también está disponible como fragmento de código de IntelliSense. En el selector de
Compilar el código
 Acceso a los miembros del espacio de nombres System. Agregue una instrucción Imports si no
incluye nombres de miembro completos en el código. Para obtener más información, vea
Instrucción Imports (Tipo y espacio de nombres de .NET).
 La instrucción Event debe estar en el nivel de la clase, no dentro de ningún procedimiento.
 La instrucción RaiseEvent debe estar dentro de algún procedimiento de la aplicación.
Vea también
Tareas
Conceptos
Referencia
Event (Instrucción)
RaiseEvent (Instrucción)
Otros recursos

En este ejemplo se define un evento, TimeExpired, y un controlador de eventos, HandleTimeExpired, y
se utiliza la instrucción AddHandler para asociarlos.
Ejemplo
Visual Basic
Copiar código
Public Event TimeExpired(ByVal Status As String)
Public Sub HandleTimeExpired(ByVal Status As String)
' Perform desired processing for when time has expired.
MsgBox("HandleTimeExpired caught the TimeExpired event" & _
Pág 84
vbCrLf & "Status = " & Status)

End Sub
Public Sub SetUpEventHandler()
AddHandler TimeExpired, AddressOf HandleTimeExpired
End Sub
Compilar el código
 Acceso a los miembros del espacio de nombres System. Agregue una instrucción Imports si no
incluye nombres de miembro completos en el código. Para obtener más información, vea
Instrucción Imports (Tipo y espacio de nombres de .NET).
 La instrucción Event debe estar en el nivel de la clase, no dentro de ningún procedimiento.
 La instrucción Event y ambos procedimientos (HandleTimeExpired y SetUpEventHandler)
deben estar definidos en la misma clase o el mismo módulo. De lo contrario, la instrucción
AddHandler debe calificar el evento y el controlador para los objetos en los que están definidos.
Vea también
Tareas
Conceptos
Referencia
Otros recursos

La forma de crear un controlador de eventos depende de cómo quiera asociarlo a los eventos. La manera
estándar de crear un controlador de eventos consiste en usar la palabra clave Handles con la palabra clave
WithEvents. Visual Basic proporciona una segunda forma de controlar los eventos: la instrucción
AddHandler. AddHandler y RemoveHandler le permiten iniciar y detener dinámicamente el control de un
evento específico. Es posible utilizar ambos enfoques, pero no se debe utilizar WithEvents y AddHandler
en el mismo evento.
Controlar eventos mediante WithEvents
La palabra clave WithEvents permite crear variables de objeto en el nivel de módulo o clase que pueden
utilizarse con la cláusula Handles en controladores de eventos.
Para controlar eventos mediante WithEvents y la cláusula Handles

1. Cree una clase simple que contiene un evento.
Visual Basic
Copiar código
Class Class1
Pág 85
Public Event AnEvent(ByVal EventNumber As Integer)

End Class
2. En la clase o el módulo que controlará el evento, utilice la palabra clave WithEvents para declarar
una variable de objeto para el código fuente de los eventos, como en el ejemplo siguiente:
Visual Basic
Copiar código
Public WithEvents ClassInst As Class1
3. En el Editor de código, elija la variable WithEvents que acaba de declarar en la lista desplegable
Nombre de clase de la parte izquierda.
4. Elija el evento que desea controlar de la lista desplegable Method Name en la parte derecha. El
Editor de código crea el procedimiento controlador de eventos vacío con una cláusula Handles.
Nota:
Este paso es opcional. Puede crear el procedimiento controlador de eventos de forma manual
mientras el procedimiento que se crea sea una subrutina, tenga la lista de argumentos correcta
para que coincida con el evento que se controla y tenga una cláusula Handles que especifique el
evento que se controla.
5. Agregue código de control de eventos al procedimiento controlador de eventos utilizando los

argumentos suministrados. El código siguiente proporciona un ejemplo:
Visual Basic
Copiar código
Public Sub ClassInst_AnEvent(ByVal EventNumber As Integer) _
Handles ClassInst.AnEvent
MsgBox("Received event number: " & CStr(EventNumber))
End Sub
Controlar eventos mediante AddHandler

Se puede utilizar la instrucción AddHandler para conectar de forma dinámica eventos a procedimientos
controladores de eventos.
Para controlar eventos mediante AddHandler

1. Cree una subrutina para controlar el evento, como en el ejemplo siguiente:
Visual Basic
Copiar código
Public Sub EHandler(ByVal EventNumber As Integer)
MsgBox("Received event number " & CStr(EventNumber))
Pág 86
End Sub
2. Declare una variable de objeto de la clase que sea el origen de los eventos y que desea controlar. A
diferencia de la variable WithEvents, puede ser una variable local en un procedimiento. Por
ejemplo:
Visual Basic
Copiar código
Public Sub TestAddHandler()
Dim CI As New Class1
End Sub
3. Utilice la instrucción AddHandler para especificar el nombre del remitente del evento, y la
instrucción AddressOf para proporcionar el nombre del controlador de eventos. Por ejemplo,
agregue el código siguiente al final de la subrutina TestAddHandler:
Visual Basic
Copiar código
AddHandler CI.AnEvent, AddressOf EHandler
Cualquier procedimiento puede servir como controlador de eventos siempre que admita los
argumentos correctos para el evento que se controla.
Utilizar RemoveHandler para detener el control de eventos
Puede utilizar la instrucción RemoveHandler para desconectar de forma dinámica eventos de
procedimientos controladores de eventos.
+Para detener el control de eventos con RemoveHandler

 Utilice la instrucción RemoveHandler para especificar el nombre del remitente del evento y la
instrucción AddressOf para proporcionar el nombre del controlador de eventos. La sintaxis para las
instrucciones RemoveHandler siempre coincidirá exactamente con la instrucción AddHandler
utilizada para iniciar el control de eventos. Por ejemplo:
Visual Basic
Copiar código
RemoveHandler CI.AnEvent, AddressOf EHandler
Controlar eventos heredados de una clase base

Las clases derivadas (clases que heredan características de una clase base) pueden controlar eventos
provocados por su clase base mediante la instrucción HandlesMyBase.
Pág 87
Controlar eventos de una clase base

 Declare un controlador de eventos en la clase derivada agregando una instrucción Handles
MyBase.nombreDeEvento a la línea de declaración del procedimiento controlador de eventos,
donde nombreDeEvento es el nombre del evento de la clase base que está controlando. Por
ejemplo:
Visual Basic
Copiar código
Public Class BaseClass
Public Event BaseEvent(ByVal i As Integer)
' Place methods and properties here.
End Class
Public Class DerivedClass

Inherits BaseClass
Sub EventHandler(ByVal x As Integer) Handles MyBase.BaseEvent
' Place code to handle events from BaseClass here.
End Sub
End Class
Vea también
Conceptos
Referencia
Handles

En el ejemplo siguiente se define una clase que produce un evento al llamar al método CauseEvent. Este
evento está controlado por un procedimiento controlador de eventos denominado EventHandler.
Ejemplo
Descripción
Para ejecutar este ejemplo, agregue el código siguiente a la clase de formulario de un proyecto de aplicación
para Windows Visual Basic y llame al procedimiento TestEvents con un argumento de tipo integer.
Código
Visual Basic
Copiar código
Public Class Class1
' Declare an event for this class.
Pág 88
Public Event Event1(ByVal EventNumber As Integer)

' Define a method that raises an event.
Sub CauseEvent(ByVal EventNumber As Integer)
RaiseEvent Event1(EventNumber)
End Sub
End Class
Protected Sub TestEvents(ByVal EventNumber As Integer)

Dim Obj As New Class1
AddHandler Obj.Event1, AddressOf Me.EventHandler
' Cause the object to raise an event.
Obj.CauseEvent(EventNumber)
End Sub
Sub EventHandler(ByVal EventNumber As Integer)

MsgBox("Received event number " & EventNumber.ToString)
End Sub
Vea también
Tareas
Conceptos

Este tutorial explica cómo declarar y provocar eventos para una clase denominada Widget. Cuando finalice
los pasos tal vez desee leer el tema complementario, Tutorial: Controlar eventos, que muestra cómo utilizar
eventos de objetos Widget para proporcionar información de estado en una aplicación.
La clase Widget
Suponga por el momento que tiene una clase Widget. Su clase Widget tiene un método que puede tardar
bastante tiempo en ejecutarse, y desea que la aplicación pueda establecer alguna clase de indicador de
finalización.
Por supuesto, podría hacer que el objeto Widget mostrara un cuadro de diálogo de porcentaje finalizado,
pero entonces ese cuadro de diálogo aparecería en cada proyecto en el que utilizase la clase Widget. Un
buen principio del diseño de objetos consiste en dejar que la aplicación que utiliza un objeto controle la
interfaz de usuario, a no ser que el objeto tenga como única finalidad administrar un formulario o un cuadro
de diálogo.
La finalidad de Widget es realizar otras tareas, de modo que es mejor agregar un evento PercentDone y
dejar que el procedimiento que llama a los métodos de Widget lo controle y muestre las actualizaciones del
estado. El evento PercentDone también puede proporcionar un mecanismo para cancelar la tarea.
Pág 89
Para generar el ejemplo de código para este tema

1. Abra un nuevo proyecto de aplicación para Windows de Visual Basic y cree un formulario llamado
Form1.
2. Agregue dos botones y una etiqueta a Form1.
3. Dé nombre a los objetos como se muestra en la tabla siguiente.
Objeto Propiedad Ajuste
Button1 Text Start Task
Button2 Text Cancelar
Label (Name), Text lblPercentDone, 0
4. En el menú Proyecto, elija Agregar clase para agregar al proyecto una clase denominada
Widget.vb.
Para declarar un evento para la clase Widget

 Utilice la palabra clave Event para declarar un evento en la clase Widget. Observe que un evento
puede tener argumentos ByVal y ByRef, como se puede ver en el evento PercentDone de
Widget:
Visual Basic
Copiar código
Public Event PercentDone(ByVal Percent As Single, _
ByRef Cancel As Boolean)
Cuando el objeto de llamada recibe un evento PercentDone, el argumento Percent contiene el porcentaje
de la tarea que se ha finalizado. El argumento Cancel se puede establecer en True para cancelar el método
que provocó el evento.
Nota:
Los argumentos de eventos se pueden declarar igual que se hace con los argumentos de
procedimientos, con las siguientes excepciones: los eventos no pueden tener argumentos
Optional, ParamArray, ni valores devueltos.
El evento PercentDone lo produce el método LongTask de la clase Widget. LongTask acepta dos
argumentos: el período de tiempo durante el cual el método simulará trabajar y el intervalo de tiempo
mínimo antes de que LongTask se detenga para provocar el evento PercentDone.
Para provocar el evento PercentDone

1. Para simplificar el acceso a la propiedad Timer utilizada por esta clase, agregue una instrucción
Imports a la parte superior de la sección de declaraciones del módulo de clase, por encima de la
instrucción Class Widget.
Visual Basic
Copiar código
Pág 90
Imports Microsoft.VisualBasic.DateAndTime
2. Agregue el código siguiente a la clase Widget:
Visual Basic
Copiar código
Public Sub LongTask(ByVal Duration As Single, _
ByVal MinimumInterval As Single)
Dim Threshold As Single
Dim Start As Single
Dim blnCancel As Boolean
' The Timer property of the DateAndTime object returns the

seconds
' and milliseconds that have passed since midnight.
Start = CSng(Timer)
Threshold = MinimumInterval
Do While CSng(Timer) < (Start + Duration)

' In a real application, some unit of work would
' be done here each time through the loop.
If CSng(Timer) > (Start + Threshold) Then
RaiseEvent PercentDone( _
Threshold / Duration, blnCancel)
' Check to see if the operation was canceled.
If blnCancel Then Exit Sub
Threshold = Threshold + MinimumInterval
End If
Loop
End Sub
Cuando su aplicación llama al método LongTask, la clase Widget provoca el evento PercentDone cada vez
que transcurran los especificados en MinimumInterval. Cuando se vuelve del evento, LongTask
comprueba si se estableció en True el argumento Cancel.
En este punto son necesarias algunas aclaraciones. Para simplificar, en el procedimiento LongTask se
supone que el usuario conoce de antemano cuánto tarda en realizarse la tarea. Esto casi nunca es así.
Dividir las tareas en bloques del mismo tamaño puede resultar difícil y, a menudo, lo que es más importante
para los usuarios es simplemente el tiempo que transcurre antes de recibir una indicación de que algo está
ocurriendo.
También puede haber detectado otro error en este ejemplo. La propiedad Timer devuelve el número de
segundos transcurridos desde medianoche; por lo tanto, la aplicación se bloquea si se inicia inmediatamente
Pág 91
antes de medianoche. Una forma más cuidadosa de medir el tiempo tendría en cuenta condiciones de límite
como ésta, o las evitaría globalmente utilizando propiedades como Now.
Ahora que la clase Widget puede provocar eventos, puede continuar con el siguiente tutorial. Tutorial:
Controlar eventos explica cómo utilizar WithEvents para asociar un controlador de eventos con el evento
PercentDone.
Vea también
Tareas
Conceptos
Referencia
Timer (Propiedad)
WithEvents
Now (Propiedad)
ByVal
ByRef

Éste es el segundo de los dos temas que muestran cómo trabajar con eventos. En el primer tema, Tutorial:
Declarar y provocar eventos, se muestra cómo declarar y provocar eventos. Esta sección utiliza el formulario
y la clase del tutorial para mostrar cómo controlar eventos cuando tienen lugar.
La clase Widget de ejemplo utiliza las instrucciones de control de eventos tradicionales. Visual Basic
proporciona otras técnicas para trabajar con eventos. Como ejercicio, puede modificar este ejemplo para
utilizar las instrucciones AddHandler y Handles.
Para controlar el evento PercentDone de la clase Widget

 Coloque el código siguiente en Form1:
Visual Basic
Copiar código
Private WithEvents mWidget As Widget
Private mblnCancel As Boolean
La palabra clave WithEvents especifica que se utiliza la variable mWidget para controlar los
eventos de un objeto. Puede especificar el tipo de objeto proporcionando el nombre de la clase de la
que se creará el objeto.
La variable mWidget se declara en Form1 porque las variables WithEvents deben ser de nivel de
clase. Esto es cierto independientemente del tipo de módulo donde se coloquen.
Pág 92
Se utiliza la variable mblnCancel para cancelar el método LongTask.

Escritura de código para controlar eventos
Tan pronto como declara una variable utilizando WithEvents, el nombre de variable aparece en la lista
desplegable izquierda del Editor de código de la clase. Cuando selecciona mWidget, aparecen los eventos de
la clase Widget en la lista desplegable derecha. Al seleccionar un evento se muestra el procedimiento de
evento correspondiente, con el prefijo mWidget y un carácter de subrayado. Se da a todos los
procedimientos de eventos asociados a la variable WithEvents el nombre de variable como prefijo.
Para controlar un evento

1. Seleccione mWidget en la lista desplegable izquierda del Editor de código.
2. Seleccione el evento PercentDone en la lista desplegable derecha. El Editor de código abre el
procedimiento de evento mWidget_PercentDone.
Nota:
El Editor de código es útil, pero no necesario, para insertar los nuevos controladores de eventos.
En este tutorial, es más directo copiar simplemente los controladores de eventos en el código.
3. Agregue el código siguiente al controlador de eventos mWidget_PercentDone:
Visual Basic
Copiar código
Private Sub mWidget_PercentDone( _
ByVal Percent As Single, _
ByRef Cancel As Boolean _
) Handles mWidget.PercentDone
lblPercentDone.Text = CInt(100 * Percent) & "%"
My.Application.DoEvents()
If mblnCancel Then Cancel = True
End Sub
Siempre que se provoca el evento PercentDone, el procedimiento de evento muestra el porcentaje

completo en un control Label. El método DoEvents permite volver a dibujar la etiqueta y también
le da al usuario la oportunidad de hacer clic en el botón Cancel.
4. Agregue el código siguiente para el controlador de eventos Button2_Click:
Visual Basic
Copiar código
Private Sub Button2_Click( _
ByVal sender As Object, _
ByVal e As System.EventArgs _
) Handles Button2.Click
mblnCancel = True
End Sub
Pág 93
Si el usuario hace clic en el botón Cancel cuando se está ejecutando LongTask, se ejecuta el evento
Button2_Click tan pronto como la instrucción DoEvents permite que se produzca el procesamiento de
eventos. La variable mblnCancel de nivel de clase se establece como True y el evento
mWidget_PercentDone lo comprueba luego y establece el argumento ByRef Cancel como True.
Conectar la variable WithEvents con un objeto
Form1 está ahora configurado para controlar los eventos de un objeto Widget. Sólo queda buscar un objeto
Widget en alguna parte.
Cuando declara una variable WithEvents en tiempo de diseño, no se asocia ningún objeto a ésta. La
variable WithEvents es como cualquier otra variable de objeto. Tendrá que crear un objeto y asignar una
referencia a éste con la variable WithEvents.
Para crear un objeto y asignarlo una referencia

1. Seleccione (Eventos Form1) en la lista desplegable izquierda del Editor de código.
2. Seleccione el evento Load en la lista desplegable derecha. El Editor de código abre el procedimiento
de evento Form1_Load.
3. Agregue el código siguiente para el procedimiento de evento Form1_Load a fin de crear el objeto
Widget:
Visual Basic
Copiar código
Private Sub Form1_Load( _
ByVal sender As System.Object, _
) Handles MyBase.Load
mWidget = New Widget
End Sub
Cuando se ejecuta este código, Visual Basic crea un objeto Widget y conecta sus eventos a los
procedimientos de evento asociados con mWidget. Desde este momento en adelante, siempre que el objeto
Widget provoque el evento PercentDone, se ejecutará el procedimiento de evento mWidget_PercentDone.
Para llamar al método LongTask

 Agregue el código siguiente al controlador de eventos Button1_Click:
Visual Basic
Copiar código
Private Sub Button1_Click( _
ByVal sender As Object, _
) Handles Button1.Click
mblnCancel = False
lblPercentDone.Text = "0%"
Pág 94
lblPercentDone.Refresh()
mWidget.LongTask(12.2, 0.33)
If Not mblnCancel Then lblPercentDone.Text = CStr(100) & "%"
End Sub
Antes de llamar al método LongTask, la etiqueta que muestra el porcentaje completo debe inicializarse y el
indicador Boolean de nivel de clase que cancela el método debe establecerse como False.
LongTask se llama con una duración de tarea de 12,2 segundos. Se provoca el evento PercentDone una
vez cada tercio de segundo. Cada vez que se provoca el evento, se ejecuta el procedimiento de evento
mWidget_PercentDone.
Cuando termina LongTask, se comprueba mblnCancel para ver si LongTask ha finalizado de forma normal
o si se ha detenido porque mblnCancel estaba establecido como True. El porcentaje completo se actualiza
sólo en el primer caso.
Para ejecutar el programa

1. Presione F5 para poner el proyecto en modo de ejecución.
2. Haga clic en el botón Iniciar tarea. Cada vez que se provoca el evento PercentDone, se actualiza la
etiqueta con el porcentaje de la tarea que se ha completado.
3. Haga clic en el botón Cancelar para detener la tarea. Observe que la apariencia del botón Cancelar
no cambia inmediatamente cuando se hace clic en él. El evento Click no puede tener lugar hasta
que la instrucción My.Application.DoEvents permita el procesamiento del evento.
Nota:
El método My.Application.DoEvents no procesa los eventos exactamente de la misma manera

en que lo hace el formulario. Por ejemplo, en este tutorial, debe hacer clic dos veces en el botón
Cancelar. Para permitir que el formulario controle directamente los eventos, puede utilizar el
subprocesamiento múltiple. Para obtener más información, vea Subprocesamiento múltiple en
Visual Basic.
Puede resultarle instructivo ejecutar el programa con F11 y recorrer el código línea a línea. Puede ver
claramente cómo la ejecución escribe LongTask y luego vuelve a escribir Form1 brevemente cada vez que
se provoca el evento PercentDone.
¿Qué sucedería si cuando se estaba devolviendo la ejecución al código de Form1, se llamara al método
LongTask de nuevo? En el peor de los casos, podría ocurrir un desbordamiento de la pila si se llamara a
LongTask cada vez que se provocara el evento.
Puede hacer que la variable mWidget controle los eventos de un objeto Widget distinto asignando una
referencia al nuevo Widget con mWidget. De hecho, puede hacer que el código de Button1_Click realice
esto cada vez que hace clic en el botón.
Para controlar eventos para un Widget distinto

 Agregue la línea de código siguiente al procedimiento Button1_Click, inmediatamente antes de la
línea que indica mWidget.LongTask(12.2, 0.33):
Visual Basic
Copiar código
mWidget = New Widget
Pág 95
' Create a new Widget object.
El código anterior crea un nuevo Widget cada vez que se hace clic en el botón. Tan pronto como finaliza el
método LongTask, se libera la referencia al objeto Widget y se destruye éste.
Las variables WithEvents pueden contener sólo una referencia a objeto a la vez, de modo que si asigna otro
objeto Widget a mWidget, los eventos del objeto Widget anterior ya no se controlarán. Si mWidget es la
única variable de objeto que contiene una referencia al objeto Widget antiguo, éste se destruirá. Si desea
controlar eventos desde varios objetos Widget, utilice la instrucción AddHandler para procesar
independientemente los eventos de cada objeto.
Nota:
Puede declarar todas las variables WithEvents que sean necesarias, pero no se admiten las
matrices de variables WithEvents.
Vea también
Tareas
Conceptos
Referencia
Handles
WithEvents
Otros recursos
Polimorfismo

Hay varias circunstancias en las que resulta importante que un controlador de eventos no bloquee los
controladores de eventos subsiguientes. Los eventos personalizados permiten al evento llamar de forma
asincrónica a sus controladores de eventos.
De manera predeterminada, el campo de almacén de respaldo de una declaración de evento es un delegado
multidifusión que combina de forma consecutiva todos los controladores de eventos. Esto significa que si un
controlador tarda mucho tiempo en completarse, bloquea a los demás controladores hasta que finaliza. (Los
controladores de eventos con buen comportamiento no deben realizar operaciones largas ni que puedan
producir bloqueos.)
En lugar de utilizar la implementación predeterminada de eventos que proporciona Visual Basic, puede
utilizar un evento personalizado para ejecutar los controladores de eventos de forma asincrónica.
Ejemplo
En este ejemplo, el descriptor de acceso AddHandler agrega el delegado para cada controlador del evento
Click en un elemento ArrayList almacenado en el campo EventHandlerList.
Cuando el código provoca el evento Click, el descriptor de acceso RaiseEvent invoca a todos los delegados
del controlador de eventos de forma asincrónica con el método BeginInvoke. Ese método invoca cada
Pág 96
controlador en un subproceso de trabajo y vuelve inmediatamente, por lo que los controladores no se

pueden bloquear entre si.
Visual Basic
Copiar código
Public NotInheritable Class ReliabilityOptimizedControl
'Defines a list for storing the delegates
Private EventHandlerList As New ArrayList
'Defines the Click event using the custom event syntax.

'The RaiseEvent always invokes the delegates asynchronously
Public Custom Event Click As EventHandler
AddHandler(ByVal value As EventHandler)
EventHandlerList.Add(value)
End AddHandler
RemoveHandler(ByVal value As EventHandler)
EventHandlerList.Remove(value)
End RemoveHandler
RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
For Each handler As EventHandler In EventHandlerList
If handler IsNot Nothing Then
handler.BeginInvoke(sender, e, Nothing, Nothing)
End If
Next
End RaiseEvent
End Event
End Class
Vea también
Tareas
Referencia
ArrayList
BeginInvoke

Hay varias circunstancias en las que es importante que una aplicación mantenga un bajo uso de memoria.
Los eventos personalizados permiten a la aplicación utilizar memoria sólo para los eventos que controla.
De manera predeterminada, cuando una clase declara un evento, el compilador asigna memoria para que un
campo almacene información de eventos. Si una clase tiene muchos eventos no usados, ocupan memoria
inútilmente.
Pág 97
En lugar de utilizar la implementación predeterminada de los eventos que Visual Basic proporciona, puede
utilizar los eventos personalizados para administrar más cuidadosamente el uso de memoria.
Ejemplo
En este ejemplo, la clase utiliza una instancia de la clase EventHandlerList, almacenada en el campo Events,
para guardar información sobre los eventos que están en uso. La clase EventHandlerList es una clase de lista
optimizada diseñada para contener delegados.
Todos los eventos de la clase usan el campo Events para realizar un seguimiento de qué métodos está
controlando cada evento.
Visual Basic
Copiar código
Public Class MemoryOptimizedBaseControl
' Define a delegate store for all event handlers.
Private Events As New System.ComponentModel.EventHandlerList
' Define the Click event to use the delegate store.

Public Custom Event Click As EventHandler
Events.AddHandler("ClickEvent", value)
End AddHandler
Events.RemoveHandler("ClickEvent", value)
End RemoveHandler
CType(Events("ClickEvent"), EventHandler).Invoke(sender, e)
End RaiseEvent
End Event
' Define the Click event to use the same delegate store.
Public Custom Event DoubleClick As EventHandler
Events.AddHandler("DoubleClickEvent", value)
End AddHandler
Events.RemoveHandler("DoubleClickEvent", value)
End RemoveHandler
CType(Events("DoubleClickEvent"),
EventHandler).Invoke(sender, e)
End RaiseEvent
End Event
' Define additional events to use the same delegate store.
Pág 98
' ...
End Class
Vea también
Tareas
Referencia
EventHandlerList
Solucionar problemas de controladores de eventos

heredados en Visual Basic
Este tema enumera problemas comunes que surgen con controladores de eventos en componentes
heredados.
Procedimientos
El código de un controlador de eventos se ejecuta dos veces por llamada

 Un controlador de eventos heredado no debe incluir una cláusula Handles. El método de la clase
base está asociado ya con el evento y se iniciará en consecuencia. Quite la cláusula Handles del
método heredado.
Visual Basic
Copiar código
' INCORRECT
Protected Overrides Sub Button1_Click( _
ByVal sender As System.Object, _
ByVal e As System.EventArgs) _
Handles Button1.Click
' The Handles clause will cause all code

' in this block to be executed twice.
End Sub
Pág 99
 Si el método heredado no tiene una palabra clave Handles, compruebe que el código no contiene
una instrucción AddHandler (Instrucción) o métodos adicionales que controlen el mismo evento.
Vea también
Tareas
Conceptos
Otros recursos

Los delegados son una forma de puntero de función orientado a objetos que permite invocar una función
indirectamente mediante una referencia a la función. Los delegados se pueden utilizar para enlazar
controladores de eventos y pasar un procedimiento de un procedimiento a otro.
En esta sección
Proporciona una introducción a los delegados y a cómo se utilizan.
Cómo: Invocar un método delegado
Proporciona un ejemplo que muestra cómo asociar un método a un delegado e invocar luego este
método a través del delegado.
Cómo: Pasar procedimientos a otro procedimiento en Visual Basic
Muestra cómo utilizar los delegados para pasar un procedimiento a otro procedimiento.
Proporciona información general sobre los eventos en Visual Basic.
Controlar y provocar eventos
Proporciona información general sobre el modelo de eventos de .NET Framework.
Describe cómo trabajar con eventos asociados a objetos de formularios Windows Forms.

Los delegados son objetos que puede utilizar para llamar a los métodos de otros objetos. Algunas veces
están descritos como punteros de función con seguridad de tipos porque son parecidos a los punteros de
función utilizados en otros lenguajes de programación. Sin embargo, a diferencia de los punteros a función,
los delegados de Visual Basic son un tipo de referencia basado en la clase System..::.Delegate. Los
delegados pueden hacer referencia a los dos métodos compartidos, métodos a los que se pueden llamar sin
una instancia específica de una clase, y a métodos de instancia.
Delegados y eventos
Los delegados son útiles en situaciones donde es necesario un intermediario entre el procedimiento que
realiza una llamada y el procedimiento que la recibe. Por ejemplo, puede que desee que un objeto que
provoca eventos sea capaz de llamar a diferentes controladores de eventos bajo diferentes circunstancias.
Pág 100
Desafortunadamente, el objeto que provoca los eventos no puede saber por adelantado qué controlador de
eventos controla un evento específico. Visual Basic permite asociar dinámicamente los controladores de
eventos a los eventos creando un delegado para el usuario cuando usa la instrucción AddHandler. En tiempo
de ejecución, el delegado remite las llamadas al controlador de eventos adecuado.
Aunque puede crear sus propios delegados, en la mayoría de los casos Visual Basic crea el delegado y se
ocupa de los detalles. Por ejemplo, una instrucción Event define de forma implícita una clase delegada
denominada <EventName>EventHandler como clase anidada de la clase que contiene la instrucción Event,
y con la misma firma que el evento. La instrucción AddressOf crea de forma implícita una instancia de un
delegado. Por ejemplo, las siguientes dos líneas de código son equivalentes:
Visual Basic
Copiar código
AddHandler Button1.Click, AddressOf Me.Button1_Click
' The previous line of code is shorthand for the next line of code.
AddHandler Button1.Click, New EventHandler(AddressOf Button1_Click)
Puede utilizar el método abreviado para crear delegados en cualquier lugar donde el compilador pueda
determinar el tipo de delegado por el contexto.
Declarar eventos que utilicen un tipo de delegado existente
En algunas situaciones, puede que desee declarar un evento para que utilice un tipo de delegado existente
como delegado subyacente. La sintaxis siguiente describe cómo hacerlo:
Visual Basic
Copiar código
Delegate Sub DelegateType()
Event AnEvent As DelegateType
Esto resulta útil cuando se desea enrutar diversos eventos hacia el mismo controlador.
Variables delegadas y parámetros
Puede utilizar delegados para otras tareas, no relacionadas con eventos, como un subprocesamiento libre o
con procedimientos que necesiten llamar a diferentes versiones de funciones en tiempo de compilación.
Por ejemplo, suponga que tiene una aplicación de anuncio clasificado que incluye un cuadro de lista con
nombres de coches. Los anuncios están ordenados por títulos, que normalmente son las marcas de los
coches. Un problema con el que puede encontrarse se produce cuando algunos coches incluyen el año del
coche antes de la marca. El problema es que la funcionalidad de ordenación integrada del cuadro de lista
ordena únicamente por códigos de carácter; primero coloca todos los anuncios que empiezan por el año y, a
continuación, los anuncios que empiezan por la marca.
Para corregir este problema, puede crear un procedimiento de ordenación en una clase que utilice la
ordenación alfabética estándar en la mayoría de los cuadros de lista, pero que pueda cambiar en tiempo de
ejecución al procedimiento de ordenación personalizado para anuncios de coches. Para ello, pasa el
procedimiento de ordenación personalizado a la clase de ordenación en tiempo de ejecución, utilizando
delegados.
Cada clase delegada define un constructor al cual se pasa la especificación de un método de objeto. Un
argumento para un constructor delegado debe ser una referencia a un método o una expresión lambda.
Para especificar una referencia a un método, utilice la sintaxis siguiente:
AddressOf [expression.]methodName
El tipo de tiempo de compilación de expression debe ser el nombre de una clase o interfaz que contenga un
método del nombre especificado cuya firma coincida con la firma de la clase delegada. methodName puede
Pág 101
ser un método compartido o un método de instancia. Aunque se cree un delegado para el método
predeterminado de la clase, methodName no es opcional.
Para especificar una expresión lambda, utilice la sintaxis siguiente:
Function ([parm como type, parm2 como type2, ...]) expression
La firma de la función debe coincidir con la del tipo de delegado. Para obtener más información sobre
expresiones lambda, vea Expresiones lambda.
Vea también
Tareas
Conceptos
Expresiones lambda
Aplicaciones multiproceso
Referencia
Delegate (Instrucción)
AddressOf (Operador)

Este ejemplo muestra cómo asociar un método a un delegado e invocar luego este método a través del
delegado.
Cree el delegado y los procedimientos correspondientes

1. Cree un delegado denominado MySubDelegate.
Copiar código
Delegate Sub MySubDelegate(ByVal x As Integer)
2. Declare una clase que contenga un método con la misma firma que el delegado.
Copiar código
Class class1
Sub Sub1(ByVal x As Integer)
MsgBox("The value of x is: " & CStr(x))
End Sub
End Class
3. Defina un método que cree una instancia del delegado e invoque el método asociado al delegado
llamando al método Invoke integrado.
Copiar código
Protected Sub DelegateTest()
Dim c1 As New class1
Pág 102
' Create an instance of the delegate.

Dim msd As MySubDelegate = AddressOf c1.Sub1
' Call the method.
msd.Invoke(10)
End Sub
Vea también
Tareas
Conceptos
Aplicaciones multiproceso
Referencia
Cómo: Pasar procedimientos a otro procedimiento en Visual

Basic
Este ejemplo muestra cómo se utilizan los delegados para pasar un procedimiento a otro.
Un delegado es un tipo que puede utilizar como cualquier otro tipo en Visual Basic. El operador AddressOf
devuelve un objeto de delegado cuando se aplica a un nombre de procedimiento.
Este ejemplo tiene un procedimiento con un parámetro de delegado que puede llevar una referencia a otro
procedimiento obtenido con el operador AddressOf.
Crear el delegado y los procedimientos correspondientes

1. Cree un delegado denominado MathOperator.
Visual Basic
Copiar código
Delegate Function MathOperator( _
ByVal x As Double, _
ByVal y As Double _
) As Double
2. Cree un procedimiento denominado AddNumbers con los parámetros y el valor devuelto que
coincidan con aquéllos de MathOperator para que coincidan las firmas.
Visual Basic
Copiar código
Function AddNumbers( _
Pág 103
ByVal y As Double _
) As Double
Return x + y
End Function
3. Cree un procedimiento denominado SubtractNumbers con una firma que coincida con
MathOperator.
Visual Basic
Copiar código
Function SubtractNumbers( _
ByVal y As Double _
) As Double
Return x - y
End Function
4. Cree un procedimiento denominado DelegateTest que tome un delegado como parámetro.

Este procedimiento puede aceptar una referencia para AddNumbers o SubtactNumbers porque sus
firmas coinciden con la firma MathOperator.
Visual Basic
Copiar código
Sub DelegateTest( _
ByVal op As MathOperator, _
ByVal y As Double _
)
Dim ret As Double
ret = op.Invoke(x, y) ' Call the method.
MsgBox(ret)
End Sub
5. Cree un procedimiento denominado Test que llame a DelegateTest una vez con el delegado para
AddNumbers como parámetro y, de nuevo, con el delegado para SubtractNumbers como
parámetro.
Visual Basic
Copiar código
Pág 104
Protected Sub Test()

DelegateTest(5, AddressOf AddNumbers, 3)
DelegateTest(9, AddressOf SubtractNumbers, 3)
End Sub
Cuando se llama a Test, muestra en primer lugar el resultado de AddNumbers al actuar sobre 5 y
3, que es 8. A continuación, se muestra el resultado de SubtractNumbers al actuar sobre 9 y 3,
que es 6.
Vea también
Tareas
Referencia
AddressOf (Operador)
Otros recursos
Conversión de delegado flexible

La conversión de delegado flexible, incluida en Visual Basic 2008, permite asignar funciones y subrutinas a
delegados o controladores de eventos cuando sus firmas no son idénticas. Por tanto, el enlace a los
delegados se vuelve coherente con el enlace ya permitido en las llamadas a métodos.
Parámetros y tipo de valor devuelto
En lugar de la coincidencia exacta de firmas, la conversión flexible requiere que se cumplan las condiciones
siguientes cuando Option Strict está establecido en On:
 Debe existir una conversión de ampliación desde el tipo de datos de cada parámetro delegado al
tipo de datos del parámetro correspondiente de la función asignada o Sub. En el ejemplo siguiente,
el delegado Del1 tiene un parámetro, Integer. El parámetro m en las expresiones lambda
asignadas debe tener un tipo de datos para el que haya una conversión de ampliación desde
Integer, como Long o Double.
Visual Basic
Copiar código
' Definition of delegate Del1.
Delegate Function Del1(ByVal arg As Integer) As Integer
Visual Basic
Copiar código
' Valid lambda expression assignments with Option Strict on or off:
Pág 105
' Integer matches Integer.

Dim d1 As Del1 = Function(m As Integer) 3
' Integer widens to Long

Dim d2 As Del1 = Function(m As Long) 3
' Integer widens to Double

Dim d3 As Del1 = Function(m As Double) 3
Sólo se permiten las conversiones de restricción cuando Option Strict está establecido en Off.
Visual Basic
Copiar código
' Valid only when Option Strict is off:
Dim d4 As Del1 = Function(m As String) CInt(m)

Dim d5 As Del1 = Function(m As Short) m
 Debe existir una conversión de ampliación en la dirección contraria desde el tipo de valor devuelto
de la función o Sub asignada al tipo de valor devuelto del delegado. En los ejemplos siguientes, el
cuerpo de cada expresión lambda asignada se debe evaluar como un tipo de datos que se amplía a
Integer, porque el tipo de valor devuelto de del1 es Integer.
Visual Basic
Copiar código
' Valid return types with Option Strict on:
' Integer matches Integer.

Dim d6 As Del1 = Function(m As Integer) m
' Short widens to Integer.

Dim d7 As Del1 = Function(m As Long) CShort(m)
' Byte widens to Integer.

Dim d8 As Del1 = Function(m As Double) CByte(m)
Si Option Strict está establecido en Off, se quita la restricción de ampliación en ambas direcciones.
Visual Basic
Copiar código
Pág 106
' Valid only when Option Strict is set to Off.
' Integer does not widen to Short in the parameter.

Dim d9 As Del1 = Function(n As Short) n
' Long does not widen to Integer in the return type.

Dim d10 As Del1 = Function(n As Integer) CLng(n)
Omisión de las especificaciones del parámetro

Los delegados flexibles también permiten omitir completamente las especificaciones del parámetro en el
método asignado:
Visual Basic
Copiar código
' Definition of delegate Del2, which has two parameters.
Delegate Function Del2(ByVal arg1 As Integer, ByVal arg2 As String) As
Integer
Visual Basic
Copiar código
' The assigned lambda expression specifies no parameters, even though
' Del2 has two parameters. Because the assigned function in this
' example is a lambda expression, Option Strict can be on or off.
' Compare the declaration of d16, where a standard function is assigned.
Dim d11 As Del2 = Function() 3
' The parameters are still there, however, as defined in the delegate.
Console.WriteLine(d11(5, "five"))
' Not valid.

' Console.WriteLine(d11())
' Console.WriteLine(d11(5))
Observe que no puede especificar algunos parámetros y omitir otros.

Visual Basic
Copiar código
' Not valid.
'Dim d12 As Del2 = Function(p As Integer) p
La capacidad de omitir parámetros es útil en una situación en la que se define un controlador de eventos,
donde están implicados varios parámetros complejos. No se usan argumentos en algunos controladores de
eventos. En su lugar, el controlador tiene directamente acceso al estado del control en el que se registra el
evento y omite los argumentos. Los delegados flexibles permiten omitir argumentos en aquellas
Pág 107
declaraciones sin ambigüedades. En el ejemplo siguiente, el método completo OnClick se puede volver a
escribir como RelaxedOnClick.
Visual Basic
Copiar código
Sub OnClick(ByVal sender As Object, ByVal e As EventArgs) Handles b.Click
MessageBox.Show("Hello World from" + b.Text)
End Sub
Sub RelaxedOnClick() Handles b.Click

MessageBox.Show("Hello World from" + b.Text)
End Sub
Ejemplos de AddressOf
Las expresiones lambda se usan en los ejemplos anteriores para que se vean fácilmente las relaciones entre
tipos. Sin embargo, se permite la misma flexibilidad para las asignaciones de delegado que usan
AddressOf, Handles o AddHandler.
En el siguiente ejemplo, las funciones f1, f2, f3 y f4 se pueden asignar a Del1.
Visual Basic
Copiar código
' Definition of delegate Del1.
Delegate Function Del1(ByVal arg As Integer) As Integer
Visual Basic
Copiar código
' Definitions of f1, f2, f3, and f4.
Function f1(ByVal m As Integer) As Integer
End Function
Function f2(ByVal m As Long) As Integer

End Function
Function f3(ByVal m As Integer) As Short

End Function
Function f4() As Integer

End Function
Visual Basic
Copiar código
' Assignments to function delegate Del1.
' Valid AddressOf assignments with Option Strict on or off:
Pág 108
' Integer parameters of delegate and function match.

Dim d13 As Del1 = AddressOf f1
' Integer delegate parameter widens to Long.

' Short return in f3 widens to Integer.

El ejemplo siguiente sólo es válido cuando Option Strict está establecido en Off.
Visual Basic
Copiar código
' If Option Strict is Off, parameter specifications for f4 can be
omitted.
' Function d16 still requires a single argument, however, as specified

' by Del1.
Console.WriteLine(d16(5))
' Not valid.

'Console.WriteLine(d16())
'Console.WriteLine(d16(5, 3))
Colocar valores devueltos de una función

La conversión de delegado flexible permite asignar una función a un delegado Sub, omitiendo así el valor
devuelto de la función. Sin embargo, no se puede asignar un Sub a un delegado de función. En el ejemplo
siguiente, la dirección de función doubler se asigna al delegado SubDel3.
Visual Basic
Copiar código
' Definition of Sub delegate Del3.
Delegate Sub Del3(ByVal arg1 As Integer)
' Definition of function doubler, which both displays and returns the
' value of its integer parameter.
Function doubler(ByVal p As Integer) As Integer
Dim times2 = 2 * p
Console.WriteLine("Value of p: " & p)
Console.WriteLine("Double p: " & times2)
Return times2
End Function
Pág 109
Visual Basic
Copiar código
' You can assign the function to the Sub delegate:
Dim d17 As Del3 = AddressOf doubler
' You can then call d17 like a regular Sub procedure.
d17(5)
' You cannot call d17 as a function. It is a Sub, and has no

' return value.
' Not valid.
'Console.WriteLine(d17(5))
Vea también
Tareas
Conceptos
Expresiones lambda
Conversiones de ampliación y de restricción
Inferencia de tipo de variable local
Referencia

Las Interfaces definen las propiedades, métodos y eventos que pueden implementar las clases. Las
interfaces le permiten definir características como grupos pequeños de propiedades, métodos y eventos
estrechamente relacionados; de esta forma se reducen los problemas de compatibilidad, ya que pueden
desarrollarse implementaciones mejoradas para las interfaces sin poner en peligro el código existente. Se
pueden agregar nuevas características en cualquier momento, mediante el desarrollo de implementaciones e
interfaces adicionales.
En versiones anteriores de Visual Basic, podía utilizar interfaces pero no crearlas directamente. En esta
versión, puede utilizar la instrucción Interface, que permite definir interfaces reales como entidades
diferenciadas a partir de clases e implementarlas con una versión mejorada de la palabra clave
Implements.
En esta sección
Información general sobre interfaces
Proporciona información general sobre los interfaces y cómo los implementa Visual Basic.
Definición de interfaz
Describe cómo definir interfaces con las instrucciones Interface y End Interface.
Palabra clave Implements e instrucción Implements
Pág 110
Describe cómo indicar que una sección de código implementa una interfaz específica.
Ejemplos de implementación de interfaces en Visual Basic
Proporciona tres ejemplos de implementación de interfaces.
Cuándo se deben utilizar interfaces
Explica cuándo se deben utilizar interfaces en lugar de una jerarquía de herencia.
Cómo: Crear e implementar interfaces
Proporciona los pasos necesarios para definir e implementar una interfaz y aporta algunos
ejemplos.
Tutorial: Crear e implementar interfaces
Proporciona un procedimiento detallado que le conduce a través del proceso de definición e
implementación de su propia interfaz.
Explica la compatibilidad de Visual Basic con la herencia y permite definir clases que sirven de base
para clases derivadas.

Las interfaces, como las clases, definen un conjunto de propiedades, métodos y eventos. Pero de forma
contraria a las clases, las interfaces no proporcionan implementación. Se implementan como clases y se
definen como entidades separadas de las clases.
Una interfaz representa un contrato, en el cual una clase que implementa una interfaz debe implementar
cualquier aspecto de dicha interfaz exactamente como esté definido.
Con las interfaces, puede definir características como grupos pequeños de miembros relacionados
estrechamente. Puede desarrollar implementaciones mejoradas para sus interfaces sin poner en peligro el
código existente, minimizando de este modo los problemas de compatibilidad. También puede agregar
nuevas características en cualquier momento, mediante el desarrollo de implementaciones e interfaces
adicionales.
A pesar de que las implementaciones de interfaces pueden evolucionar, las propias interfaces no pueden
cambiarse una vez editadas. Los cambios que se realicen en una interfaz editada pueden interrumpir el
código existente. Si piensa en una interfaz como si fuera un contrato, resulta evidente que ambas partes del
contrato tienen un papel específico. El editor de una interfaz se compromete a no cambiar nunca la interfaz,
y la persona que la implementa se compromete a implementarla exactamente tal y como haya sido
diseñada.
En versiones anteriores de Visual Basic, podía utilizar interfaces pero no crearlas directamente. Ahora puede
definir verdaderas interfaces mediante la instrucción Interface e implementarlas con una versión mejorada
de la palabra clave Implements.
Vea también
Tareas
Conceptos
Pág 111
Referencia
Instrucción Interface (Visual Basic)
Otros recursos
Las definiciones de interfaz se encuentran dentro de las instrucciones Interface y End Interface. Después
de la instrucción Interface, puede agregar una instrucción Inherits opcional que proporciona una lista de
una o varias interfaces heredadas. Las instrucciones Inherits deben ir antes que el resto de instrucciones de
una declaración, a excepción de los comentarios. El resto de instrucciones de una definición de interfaz
deberían ser instrucciones Event, Sub, Function, Property, Interface, Class, Structure y Enum. Las
interfaces no pueden contener código de implementación ni instrucciones asociadas a código de
implementación, como End Sub o End Property.
En un espacio de nombres, las instrucciones de interfaz son de manera predeterminada Friend, pero
también se pueden declarar explícitamente como Public o Friend. Las interfaces definidas dentro de las
clases, módulos, interfaces y estructuras son de manera predeterminada Public, pero también se pueden
declarar explícitamente como Public, Friend, Protected o Private.
Nota:
La palabra clave Shadows se puede aplicar a todos los miembros de la interfaz. La palabra clave
Overloads se puede aplicar a las instrucciones declaradas Sub, Function y Property en la
definición de una interfaz. Además, las instrucciones Property pueden tener los modificadores
Default, ReadOnly o WriteOnly. No se permite ninguno del resto de los modificadores: Public,
Private, Friend, Protected, Shared, Overrides, MustOverride o Overridable. Para obtener
más información, vea Contextos de declaración y niveles de acceso predeterminados.
Vea también
Tareas
Conceptos
Referencia
Inherits (Instrucción)
Overloads
Default (Visual Basic)
Otros recursos
Pág 112

La palabra reservada Implements de Visual Basic se utiliza de dos formas. La instrucción Implements
significa que una clase o estructura implementa una interfaz. La palabra clave Implements significa que un
miembro de clase o de estructura implementa un miembro de interfaz específico.
Instrucción de implementación
Si una clase o estructura implementa una o más interfaces, debe incluir la instrucción Implements
inmediatamente después de la instrucción Class o Structure. La instrucción Implements exige que una
lista separada por comas de interfaces sea implementada por una clase. La clase o estructura debe
implementar todos los miembros de interfaz mediante la palabra clave Implements.
La palabra clave Implements
La palabra clave Implements requiere una lista separada por comas de los miembros de la interfaz que
deben implementarse. Por lo general, se especifica solamente un único miembro de interfaz, pero se pueden
especificar varios miembros. La especificación de un miembro de interfaz consta del nombre de la interfaz,
que debe especificarse en una instrucción Implements dentro de la clase, un punto y el nombre del evento,
propiedad o función miembro que debe implementarse. El nombre de un miembro que implementa un
miembro de interfaz puede utilizar cualquier identificador permitido y no se limita a la convención
InterfaceName_MethodName que se utilizaba en las versiones anteriores de Visual Basic.
Por ejemplo, el código siguiente muestra cómo declarar una subrutina denominada Sub1 que implementa un
método de una interfaz:
Visual Basic
Copiar código
Class Class1
Implements interfaceclass.interface2
Sub Sub1(ByVal i As Integer) Implements

interfaceclass.interface2.Sub1
End Sub
End Class
Los tipos de parámetro y de valores devueltos del miembro que realiza la implementación deben coincidir
con la propiedad de interfaz o la declaración de miembro de la interfaz. La forma más habitual de
implementar un elemento de una interfaz es con un miembro que tenga el mismo nombre que la interfaz,
como se muestra en el ejemplo anterior.
Para declarar la implementación de un método de interfaz, puede utilizar cualquier atributo permitido en las
declaraciones de método de instancia, incluidos Overloads, Overrides, Overridable, Public, Private,
Protected, Friend, Protected Friend, MustOverride, Default y Static. El atributo Shared no está
permitido, ya que define una clase en lugar de un método de instancia.
Con Implements también puede crear un único método que implemente varios métodos definidos en una
interfaz, como en el ejemplo siguiente:
Visual Basic
Copiar código
Class Class2
Implements I1, I2
Pág 113
Protected Sub M1() Implements I1.M1, I1.M2, I2.M3, I2.M4

End Sub
End Class
Puede utilizar un miembro privado para implementar un miembro de interfaz. Cuando un miembro privado
implementa un miembro de una interfaz, el miembro pasa a estar disponible por medio de la interfaz,
aunque no está disponible directamente en las variables de objeto para la clase.
Vea también
Tareas
Conceptos
Referencia
Implements (Instrucción)
Implements (Visual Basic)
Otros recursos

Las clases que implementan una interfaz deben implementar todas sus propiedades, métodos y eventos.
El ejemplo siguiente define dos interfaces. La segunda interfaz, Interface2, hereda Interface1 y define
un método y una propiedad adicional.
Visual Basic
Copiar código
Interface Interface1
Sub sub1(ByVal i As Integer)
End Interface
' Demonstrates interface inheritance.

Interface Interface2
Inherits Interface1
Sub M1(ByVal y As Integer)
ReadOnly Property Num() As Integer
End Interface
El ejemplo siguiente implementa Interface1, la interfaz definida en el ejemplo anterior:

Visual Basic
Copiar código
Public Class ImplementationClass1
Pág 114
Implements Interface1
Sub Sub1(ByVal i As Integer) Implements Interface1.sub1
' Insert code here to implement this method.
End Sub
End Class
El ejemplo final implementa Interface2, incluyendo un método heredado de Interface1:

Visual Basic
Copiar código
Public Class ImplementationClass2
Implements Interface2
Dim INum As Integer = 0
Sub sub1(ByVal i As Integer) Implements Interface2.sub1
' Insert code here that implements this method.
End Sub
Sub M1(ByVal x As Integer) Implements Interface2.M1
' Insert code here to implement this method.
End Sub
ReadOnly Property Num() As Integer Implements _

Interface2.Num
Get
Num = INum
End Get
End Property
End Class
Vea también
Tareas
Conceptos
Referencia
Pág 115

Las interfaces son una herramienta de programación eficaz porque le permiten separar la definición de
objetos de su implementación. La herencia de clases y las interfaces tienen ventajas e inconvenientes, y
puede que al final decida utilizar una combinación de ambas en sus proyectos. Esta página y Cuándo utilizar
la herencia le ayudarán a determinar qué enfoque es mejor para su situación.
Flexibilidad en la implementación
Existen otras razones por las que se podría desear utilizar interfaces en lugar de la herencia de clases:
 Las interfaces admiten mejor las situaciones en las cuales las aplicaciones necesitan el mayor
número de tipos de objetos no relacionados posible para proporcionar determinadas funciones.
 Las interfaces son más flexibles que las clases de base, porque puede definir una única
implementación que puede implementar interfaces múltiples.
 Las interfaces son mejores en situaciones en las que no es necesario heredar una implementación
de una clase de base.
 Las interfaces son útiles cuando no se puede usar la herencia de clases. Por ejemplo, las
estructuras no pueden heredarse de las clases, pero pueden implementar interfaces.
Vea también
Tareas
Conceptos
Cuándo utilizar la herencia
Otros recursos
Contraer todo

Como se explica en Información general sobre interfaces, las interfaces describen las propiedades, métodos
y eventos de una clase sin proporcionar ninguna implementación.
Para crear una interfaz

1. Defina la interfaz agregándole código, de tal forma que empiece con la palabra clave Interface y el
nombre de la interfaz, y que acabe con la instrucción End Interface. Por ejemplo, el siguiente
código define una interfaz denominada IAsset.
Pág 116
Visual Basic
Copiar código
Interface IAsset
End Interface
2. Agregue instrucciones que definan las propiedades, métodos y eventos que sean compatibles con la
interfaz. Por ejemplo, el siguiente código define una función, una propiedad y un evento.
Visual Basic
Copiar código
Interface IAsset
Event ComittedChange(ByVal Success As Boolean)
Property Division() As String
Function GetID() As Integer
End Interface
Para implementar una interfaz

1. Si la interfaz que está implementando no forma parte del proyecto, agregue una referencia al
ensamblado que contiene la interfaz.
2. Cree una clase nueva que implemente la interfaz, e incluya la palabra clave Implements en la
línea que sigue al nombre de clase. Por ejemplo, para implementar la interfaz IAsset, podría darle
a la clase de implementación el nombre Computer, como en el código siguiente.
Visual Basic
Copiar código
Class Computer
Implements IAsset
End Class
3. Agregue procedimientos para implementar las propiedades, métodos y eventos de la clase como en
el código siguiente, que se basa en el ejemplo del paso anterior:
Visual Basic
Copiar código
Class Computer
Implements IAsset
Public Event ComittedChange(ByVal Success As Boolean) _

Implements IAsset.ComittedChange
Pág 117
Private divisionValue As String
Public Property Division() As String _

Implements IAsset.Division
Get
Return divisionValue
End Get
Set(ByVal value As String)
divisionValue = value
RaiseEvent ComittedChange(True)
End Set
End Property
Private IDValue As Integer
Public Function GetID() As Integer _

Implements IAsset.GetID
Return IDValue
End Function
Public Sub New(ByVal Division As String, ByVal ID As Integer)

Me.divisionValue = Division
Me.IDValue = ID
End Sub
End Class
Vea también
Tareas
Conceptos
Referencia
Otros recursos
Pág 118

Las interfaces describen las características de las propiedades, los métodos y los eventos, pero dejan los
detalles de la implementación para las estructuras o clases.
Este tutorial explica cómo declarar e implementar una interfaz.
Nota:
Ayuda, dependiendo de los valores de configuración o de edición activos. Para cambiar la
configuración, seleccione Importar y exportar configuraciones en el menú Herramientas. Para
Para definir una interfaz

1. Abra un nuevo proyecto Aplicación para Windows de Visual Basic.
2. Agregue un módulo nuevo al proyecto haciendo clic en Agregar módulo en el menú Proyecto.
3. Asigne al módulo el nombre Module1.vb y haga clic en Agregar. Aparecerá el código del módulo
nuevo.
4. Defina una interfaz con el nombre TestInterface dentro de Module1; para ello, escriba
Interface TestInterface entre las instrucciones Module y End Module y presione ENTRAR. El
Editor de código aplica una sangría delante de la palabra clave Interface y agrega una instrucción
End Interface para formar un bloque de código.
5. Defina una propiedad, un método y un evento para la interfaz; para ello, sitúe el siguiente código
entre las instrucciones Interface y End Interface:
Visual Basic
Copiar código
Property Prop1() As Integer
Sub Method1(ByVal X As Integer)
Event Event1()
Implementación
Puede notar que la sintaxis utilizada para declarar los miembros de la interfaz es diferente de la sintaxis
utilizada para declarar los miembros de la clase. Esta diferencia refleja el hecho de que las interfaces no
pueden contener código de implementación.
Para implementar la interfaz

1. Agregue una clase denominada ImplementationClass; para ello, agregue la siguiente instrucción
a Module1 después de la instrucción End Interface pero antes de la instrucción End Module y, a
continuación, presione ENTRAR:
Visual Basic
Copiar código
Pág 119
Class ImplementationClass
Si está trabajando dentro del entorno de desarrollo integrado, el Editor de código proporciona la
instrucción End Class correspondiente al presionar ENTRAR.
2. Agregue la siguiente instrucción Implements a ImplementationClass, que da nombre a la
interfaz que implementa la clase:
Visual Basic
Copiar código
Implements TestInterface
Cuando se muestra separada de otros elementos en la parte superior de la clase o estructura, la

instrucción Implements indica que la clase o estructura implementa una interfaz.
Si está trabajando dentro del entorno de desarrollo integrado, el Editor de código implementa los
miembros de clase requeridos por TestInterface al presionar ENTRAR, y se puede omitir el paso
siguiente.
3. Si no está trabajando dentro del entorno de desarrollo integrado, debe implementar todos los
miembros de la interfaz MyInterface. Agregue el código siguiente a ImplementationClass para
implementar Event1, Method1 y Prop1:
Visual Basic
Copiar código
Event Event1() Implements TestInterface.Event1
Public Sub Method1(ByVal X As Integer) Implements

TestInterface.Method1
End Sub
Public Property Prop1() As Integer Implements TestInterface.Prop1

Get
End Get
Set(ByVal value As Integer)
End Set
End Property
La instrucción Implements asigna un nombre a la interfaz y al miembro de la interfaz que se está

implementando.
4. Para finalizar la definición de Prop1, agregue un campo privado a la clase que almacenó el valor de
la propiedad:
Visual Basic
Pág 120
Copiar código
' Holds the value of the property.
Private pval As Integer
Devuelva el valor de pval desde el descriptor de acceso get de la propiedad.
Visual Basic
Copiar código
Return pval
Establezca el valor de pval en el descriptor de acceso set de la propiedad.
Visual Basic
Copiar código
pval = value
5. Para finalizar la definición de Method1, agregue el código siguiente:
Visual Basic
Copiar código
MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()
Para probar la implementación de la interfaz

1. Haga clic con el botón secundario del mouse (ratón) en el formulario de inicio del proyecto en el
Explorador de soluciones y haga clic en Ver código. El editor mostrará la clase del formulario de
inicio. De manera predeterminada, el formulario de inicio se denomina Form1.
2. Agregue el siguiente campo testInstance a la clase Form1:
Visual Basic
Copiar código
Dim WithEvents testInstance As TestInterface
Al declarar testInstance como WithEvents, la clase Form1 puede controlar sus eventos.
3. Agregue el siguiente controlador de eventos a la clase Form1 para controlar los eventos
desencadenados por testInstance:
Visual Basic
Copiar código
Pág 121
Sub EventHandler() Handles testInstance.Event1

MsgBox("The event handler caught the event.")
End Sub
4. Agregue una subrutina denominada Test a la clase Form1 para probar la clase de implementación:
Visual Basic
Copiar código
Sub Test()
' Create an instance of the class.
Dim T As New ImplementationClass
' Assign the class instance to the interface.
' Calls to the interface members are
' executed through the class instance.
testInstance = T
' Set a property.
testInstance.Prop1 = 9
' Read the property.
MsgBox("Prop1 was set to " & testInstance.Prop1)
' Test the method and raise an event.
testInstance.Method1(5)
End Sub
El procedimiento Test crea una instancia de la clase que implementa MyInterface, asigna esa
instancia al campo testInstance, define una propiedad y ejecuta un método a través de la
interfaz.
5. Agregue código para llamar al procedimiento Test desde el procedimiento Form1 Load del
formulario de inicio:
Visual Basic
Copiar código
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) _
Handles MyBase.Load
Test() ' Test the class.
End Sub
6. Ejecute el procedimiento Test presionando F5. Aparecerá el mensaje "Prop1 se ha definido como
9". Tras hacer clic en Aceptar, aparecerá el mensaje "El parámetro X de Method1 es 5". Al hacer clic
en Aceptar, aparecerá el mensaje "El controlador de eventos ha interceptado el evento".
Vea también
Pág 122
Tareas
Conceptos
Referencia
Otros recursos

Visual Basic admite el concepto de herencia, que es la posibilidad de definir clases que sirven de base para
clases derivadas. Las clases derivadas heredan, y pueden extender, las propiedades, métodos y eventos de
la clase base. Las clases derivadas también pueden reemplazar métodos heredados con nuevas
implementaciones. De manera predeterminada, se pueden heredar todas las clases creadas con Visual Basic.
La herencia permite escribir y depurar una clase una vez, y después volver a usar ese código como base de
nuevas clases. La herencia también permite usar el polimorfismo basado en la herencia, que se trata de la
posibilidad de definir clases que pueden usarse de forma intercambiable mediante código cliente en tiempo
de ejecución, pero con funcionalidad diferente, incluso con métodos o propiedades denominados de manera
idéntica.
En esta sección
Se describen los modificadores de herencia, la forma de reemplazar métodos y propiedades,
MyClass y MyBase.
Cómo: Crear clases derivadas
Proporciona una descripción paso a paso de cómo crear clases derivadas.
Se explica cuándo se debe utilizar la herencia en lugar de interfaces.
Herencia y .NET Framework
Explica cómo .NET Framework admite la herencia.
Se describe la forma de utilizar objetos COM existentes como base de nuevos objetos.
La herencia y la clase de objeto base
Se proporciona información general sobre la clase que sirve de base para todas las demás clases.
Cómo funcionan los métodos New y Finalize en una jerarquía de clases
Se describe la forma de llamar a constructores y destructores en una jerarquía de clases.
Polimorfismo
Se describe el polimorfismo y se explica la forma de utilizarlo.
Diseñar una jerarquía de herencia
Se proporciona información sobre cómo diseñar e implementar una jerarquía de clases.
Se ofrece un resumen que describe las interfaces y la forma de utilizarlas.
Pág 123
Se presentan los conceptos de programación orientada a objetos usados en Visual Basic.
La instrucción Inherits se utiliza para declarar una nueva clase, denominada clase derivada, basada en una
clase existente conocida como clase base. Las clases derivadas heredan, y pueden extender, las
propiedades, métodos, eventos, campos y constantes definidos en la clase base. En la siguiente sección se
describen algunas de las reglas de herencia, así como los modificadores que se pueden utilizar para cambiar
la forma en que las clases heredan o son heredadas:
 De forma predeterminada, todas las clases son heredables a menos que se marquen con la palabra
clave NotInheritable. Las clases pueden heredar de otras clases del proyecto o de clases en otros
ensamblados a los que hace referencia el proyecto.
 A diferencia de los lenguajes que permiten la herencia múltiple, Visual Basic solamente permite la
herencia simple en las clases; es decir, las clases derivadas solo pueden tener una clase base.
Aunque no se permite la herencia múltiple en las clases, éstas pueden implementar múltiples
interfaces, lo que permite lograr de manera eficaz los mismos fines.
 Para evitar la exposición de elementos restringidos en una clase base, el tipo de acceso de una
clase derivada debe ser igual o más restrictivo que el de su clase base. Por ejemplo, una clase
Public no puede heredar una clase Friend o Private, y una clase Friend no puede heredar una
clase Private.
Modificadores de herencia
Visual Basic presenta las siguientes instrucciones y modificadores de nivel de clase para ofrecer
compatibilidad con la herencia:
 Instrucción Inherits: especifica la clase base.
 Modificador NotInheritable: impide que los programadores utilicen la clase como clase base.
 Modificador MustInherit: especifica que la clase sólo se debe utilizar como clase base. Las
instancias de las clases MustInherit no se pueden crear directamente; sólo se pueden crear como
instancias de clase base de una clase derivada. Otros lenguajes de programación, como C++ y C#,
utilizan el término clase abstracta para describir tal clase.
Reemplazar propiedades y métodos en clases derivadas
De forma predeterminada, una clase derivada hereda los métodos y propiedades de su clase base. Si una
propiedad o método heredados tienen que comportarse de manera diferente en la clase derivada, se pueden
invalidar. Es decir, se puede definir una nueva implementación del método en la clase derivada. Los
siguientes modificadores se utilizan para controlar cómo se reemplazan propiedades y métodos:
 Overridable: permite reemplazar una propiedad o un método de una clase en una clase derivada.
 Overrides: reemplaza una propiedad o un método Overridable definido en la clase base.
 NotOverridable: evita que una propiedad o un método se invaliden en una clase que hereda. De
forma predeterminada, los métodos Public son NotOverridable.
 MustOverride: requiere que una clase derivada reemplace una propiedad o un método. Cuando se
utiliza la palabra clave MustOverride, la definición del método está formada simplemente por la
instrucción Sub, Function o Property. No se permite ninguna otra instrucción y no hay
específicamente ninguna instrucción End Sub o End Function. Los métodos MustOverride se
deben declarar en las clases MustInherit.
Para obtener más información sobre los métodos de reemplazo, consulte Invalidar propiedades y métodos.
La palabra clave MyBase
Pág 124
Puede utilizar la palabra clave MyBase para llamar a métodos de una clase base cuando invalide métodos en
una clase derivada. Por ejemplo, suponga que diseña una clase derivada que reemplaza un método
heredado de la clase base. El método reemplazado puede llamar al método de la clase base y modificar el
valor devuelto como se muestra en el fragmento de código siguiente:
Visual Basic
Copiar código
Class DerivedClass
Inherits BaseClass
Public Overrides Function CalculateShipping( _
ByVal Dist As Double, _
ByVal Rate As Double) _
As Double
' Call the method in the base class and modify the return value.
Return MyBase.CalculateShipping(Dist, Rate) * 2
End Function
End Class
En la lista siguiente se describen las restricciones de uso de MyBase:

 MyBase hace referencia a la clase base inmediata y a sus miembros heredados. No se puede
utilizar para tener acceso a miembros Private de la clase.
 MyBase es una palabra clave, no un objeto real. MyBase no se puede asignar a una variable,
pasar a procedimientos o utilizar en una comparación Is.
 No es necesario definir el método al que certifica MyBase en la clase base inmediata; puede
definirse en una clase base heredada indirectamente. Para compilar correctamente una referencia
certificada mediante MyBase, alguna clase base debe contener un método que se corresponda con
el nombre y los tipos de los parámetros que aparecen en la llamada.
 No puede utilizar MyBase para llamar a métodos de clase base con el modificador MustOverride.
 No se puede utilizar MyBase para calificarse a sí misma. Por tanto, el siguiente código no es válido:
MyBase.MyBase.BtnOK_Click()
 No se puede utilizar MyBase en módulos.
 No se puede utilizar MyBase para tener acceso a miembros de clase base marcados como Friend si
la clase base está en un ensamblado diferente.
La palabra clave MyClass
La palabra clave MyClass permite llamar a un método Overridable implementado en la clase y asegurarse
de que se llama a la implementación del método en esta clase y no a la de un método invalidado en una
clase derivada.
 MyClass es una palabra clave, no un objeto real. MyClass no se puede asignar a una variable,
pasar a procedimientos o utilizar en una comparación Is.
 MyClass hace referencia a la clase base inmediata y a sus miembros heredados.
 MyClass puede utilizarse como calificador de miembros Shared.
 MyClass no se puede utilizar en módulos estándar.
 MyClass puede utilizarse para calificar un método que está definido en un clase base y que no tiene
ninguna implementación del método proporcionado en esa clase. Este tipo de referencia tiene el
mismo significado que MyBase.Método.
Vea también
Pág 125
Tareas
Conceptos
Referencia
Otros recursos

La instrucción Inherits hace que una clase herede todos los miembros no privados de la clase especificada.
Para heredar de otra clase

 Agregue una instrucción Inherits (con el nombre de una clase que desee utilizar como clase base)
como primera instrucción de la clase derivada. La instrucción Inherits debe ser la primera
instrucción sin comentario después de la instrucción de clase.
Ejemplo
El ejemplo siguiente define dos clases. La primera es una clase base que tiene dos métodos. La segunda
hereda los dos métodos de la clase base, reemplaza el segundo método y define un campo denominado
Field.
Visual Basic
Copiar código
Class Class1
Sub Method1()
MsgBox("This is a method in the base class.")
End Sub
Overridable Sub Method2()
MsgBox("This is another method in the base class.")
End Sub
End Class
Class Class2
Inherits Class1
Public Field2 As Integer
Overrides Sub Method2()
MsgBox("This is a method in a derived class.")
End Sub
End Class
Protected Sub TestInheritance()

Dim C1 As New Class1
Dim C2 As New Class2
Pág 126
C1.Method1() ' Calls a method in the base class.

C1.Method2() ' Calls another method from the base class.
C2.Method1() ' Calls an inherited method from the base class.
C2.Method2() ' Calls a method from the derived class.
End Sub
Al ejecutar el procedimiento TestInheritance, aparecen los siguientes mensajes:

This is a method in the base class.
This is another method in the base class.
This is a method in the base class.
This is a method in a derived class.
Vea también
Conceptos
Otros recursos

La herencia es un concepto de programación útil, pero es fácil utilizarlo de manera poco adecuada. A
menudo, las interfaces solucionan mejor la situación. Este tema y Cuándo se deben utilizar interfaces le
ayudan a entender cuándo se debe utilizar cada enfoque.
La herencia es una buena opción cuando:
 La jerarquía de herencia representa una relación de identidad y no una relación de pertenencia.
 Se puede volver a utilizar código de las clases base.
 Es necesario aplicar la misma clase y los mismos métodos a tipos de datos diferentes.
 La jerarquía de clases es poco profunda y es poco probable que otros programadores agreguen
muchos más niveles.
 Desea realizar cambios globales en clases derivadas modificando una clase base.
Estas consideraciones se explican en este orden a continuación.
Herencia y relaciones de identidad
Dos maneras de mostrar las relaciones de clase en la programación orientada a objetos son las relaciones de
identidad y de pertenencia. En una relación de identidad, la clase derivada es claramente un tipo de clase
base. Por ejemplo, una clase denominada PremierCustomer representa una relación de tipo identidad con
una clase base denominada Customer, puesto que un cliente principal es un cliente. No obstante, una clase
denominada CustomerReferral representa una relación de pertenencia con la clase Customer porque una
cartera de clientes tiene un cliente, pero no es un tipo de cliente.
Los objetos de una jerarquía de herencia deben tener una relación de identidad con la clase base puesto que
heredan los campos, propiedades, métodos y eventos definidos en dicha clase. Las clases que representan
una relación de pertenencia con otras clases no son válidas para jerarquías de herencia debido a que podrían
heredar propiedades y métodos inadecuados. Por ejemplo, si la clase CustomerReferral se derivase de la
clase Customer descrita anteriormente, podría heredar propiedades que no tendrían sentido, como
ShippingPrefs y LastOrderPlaced. Las relaciones de pertenencia como ésta deben representarse
Pág 127
mediante clases o interfaces no relacionadas. La siguiente ilustración muestra ejemplos de relaciones de tipo
"es un" y "tiene un".
Clases base y reutilización de código

Otra razón para usar la herencia es la ventaja de poder reutilizar el código. Las clases bien diseñadas, una
vez depuradas, pueden utilizarse una y otra vez como base de nuevas clases.
Un ejemplo común de reutilización eficaz de código está relacionado con bibliotecas que administran
estructuras de datos. Por ejemplo, suponga que tiene una gran aplicación comercial que administra varias
clases de listas en la memoria. Una es una copia en memoria de la base de datos de clientes, que se lee
desde una base de datos al iniciar la sesión para conseguir mayor velocidad. La estructura de datos tendría
un aspecto similar al siguiente:
Visual Basic
Copiar código
Class CustomerInfo
Protected PreviousCustomer As CustomerInfo
Protected NextCustomer As CustomerInfo
Public ID As Integer
Public FullName As String
Public Sub InsertCustomer(ByVal FullName As String)

' Insert code to add a CustomerInfo item to the list.
End Sub
Public Sub DeleteCustomer()

' Insert code to remove a CustomerInfo item from the list.
End Sub
Public Function GetNextCustomer() As CustomerInfo

' Insert code to get the next CustomerInfo item from the list.
Pág 128
Return NextCustomer
End Function
Public Function GetPrevCustomer() As CustomerInfo

'Insert code to get the previous CustomerInfo item from the list.
Return PreviousCustomer
End Function
End Class
La aplicación también podría tener una lista similar de productos que el usuario ha agregado a una lista del
carro de la compra, como se muestra en el siguiente fragmento de código:
Visual Basic
Copiar código
Class ShoppingCartItem
Protected PreviousItem As ShoppingCartItem
Protected NextItem As ShoppingCartItem
Public ProductCode As Integer
Public Function GetNextItem() As ShoppingCartItem
' Insert code to get the next ShoppingCartItem from the list.
Return NextItem
End Function
End Class
Aquí puede ver un modelo: dos listas se comportan del mismo modo (inserciones, eliminaciones y
recuperaciones) pero funcionan con tipos de datos diferentes. Mantener dos bases de código para realizar
esencialmente las mismas funciones no es eficaz. La solución más eficaz consiste en separar la
administración de listas en su propia clase y después heredar de esa clase para diferentes tipos de datos:
Visual Basic
Copiar código
Class ListItem
Protected PreviousItem As ListItem
Protected NextItem As ListItem
Public Function GetNextItem() As ListItem
' Insert code to get the next item in the list.
Return NextItem
End Function
Public Sub InsertNextItem()
' Insert code to add a item to the list.
End Sub
Public Sub DeleteNextItem()

' Insert code to remove a item from the list.
Pág 129
End Sub
Public Function GetPrevItem() As ListItem

'Insert code to get the previous item from the list.
Return PreviousItem
End Function
End Class
La clase ListItem sólo tiene que ser depurada una vez. Después podrá generar clases que la utilicen sin
tener que pensar nunca más sobre la administración de listas. Por ejemplo:
Visual Basic
Copiar código
Class CustomerInfo
Inherits ListItem
Public ID As Integer
Public FullName As String
End Class
Class ShoppingCartItem
Inherits ListItem
Public ProductCode As Integer
End Class
Aunque la reutilización de código basado en la herencia es una herramienta eficaz, también tiene riesgos
asociados. Incluso los sistemas mejor diseñados cambian a veces de tal modo que los diseñadores no
podrían prever. A veces, los cambios en una jerarquía de clases existente pueden tener consecuencias no
deseadas; en la sección Cambios en el diseño de la clase base después de la implementación de "El
problema de fragilidad de la clase base" se describen algunos ejemplos.
Clases derivadas intercambiables
Las clases derivadas de una jerarquía de clases pueden a veces intercambiarse con la clase base, un proceso
denominado polimorfismo basado en la herencia. Este enfoque combina las mejores características del
polimorfismo basado en la interfaz con la opción de reutilizar o reemplazar código de una clase base.
Así, esto podría ser útil en un paquete de dibujo. Por ejemplo, considere el siguiente fragmento de código,
que no utiliza herencia:
Visual Basic
Copiar código
Sub Draw(ByVal Shape As DrawingShape, ByVal X As Integer, _
ByVal Y As Integer, ByVal Size As Integer)
Select Case Shape.type

Case shpCircle
' Insert circle drawing code here.
Case shpLine
' Insert line drawing code here.
Pág 130
End Select
End Sub
Este enfoque presenta algunos problemas. Si alguien decide agregar una opción de elipse posteriormente,
será necesario modificar el código fuente; puede ocurrir que los usuarios a los que va dirigido ni siquiera
tengan acceso al código fuente. Un problema más sutil consiste en que para dibujar una elipse se necesita
otro parámetro (las elipses tienen un diámetro principal y uno secundario) que no sería relevante para el
caso de la línea. Si alguien desea agregar una polilínea (múltiples líneas conectadas), entonces se agregaría
otro parámetro que no sería relevante para otros casos.
La herencia resuelve la mayoría de estos problemas. Las clases base bien diseñadas dejan la implementación
de métodos específicos para las clases derivadas, de modo que se pueda incluir cualquier forma. Otros
programadores pueden implementar métodos en clases derivadas con la documentación de la clase base.
Otros elementos de clase (como las coordenadas x e y) se pueden integrar en la clase base porque todas las
descendientes los utilizan. Por ejemplo, Draw podría ser un método MustOverride:
Visual Basic
Copiar código
MustInherit Class Shape
Public X As Integer
Public Y As Integer
MustOverride Sub Draw()
End Class
Después podría agregar los elementos necesarios a esa clase para las diferentes formas. Por ejemplo, una
clase Line podría necesitar únicamente un campo Length:
Visual Basic
Copiar código
Class Line
Inherits Shape
Public Length As Integer
Overrides Sub Draw()
' Insert code here to implement Draw for this shape.
End Sub
End Class
Este planteamiento es útil debido a que otros programadores que no tienen acceso al código fuente pueden
extender la clase base con nuevas clases derivadas según sea necesario. Por ejemplo, una clase denominada
Rectangle podría derivarse de la clase Line:
Visual Basic
Copiar código
Class Rectangle
Inherits Line
Public Width As Integer
Overrides Sub Draw()
Pág 131
' Insert code here to implement Draw for the Rectangle shape.
End Sub
End Class
En este ejemplo se muestra cómo se puede pasar de clases de propósito general a clases muy específicas
mediante la implementación de detalles en cada nivel.
En este punto podría ser conveniente volver a evaluar si la clase derivada realmente representa una relación
de identidad o, por el contrario, es una relación de pertenencia. Si la nueva clase de rectángulo se compone
solamente de líneas, entonces la herencia no es la mejor opción. No obstante, si el nuevo rectángulo es una
línea con una propiedad de ancho, entonces se mantiene la relación de identidad.
Jerarquías de clases poco profundas
La herencia se adapta mejor a jerarquías de clases relativamente poco profundas. Las jerarquías de clases
complejas y profundas en exceso pueden ser difíciles de desarrollar. La decisión de utilizar una jerarquía de
clases implica sopesar sus ventajas y su complejidad. Como norma general, las jerarquías deberían limitarse
a seis niveles o menos. No obstante, la profundidad máxima de una jerarquía de clases concreta depende de
varios factores, incluida la complejidad de cada nivel.
Cambios globales en clases derivadas a través de la clase base
Una de las características más eficaces de la herencia es la posibilidad de realizar cambios en una clase base
que se propagan a las clases derivadas. Si se usa con cuidado, puede actualizarse la implementación de un
solo método y decenas, e incluso cientos, de clases derivadas podrán utilizar el nuevo código. No obstante,
esta práctica puede resultar peligrosa puesto que tales cambios podrían generar problemas en clases
heredadas diseñadas por otras personas. Debe tenerse cuidado para asegurarnos de que la nueva clase es
compatible con las clases que utilizan la original. Concretamente, debe evitarse cambiar el nombre o el tipo
de los miembros de la clase base.
Suponga, por ejemplo, que diseña una clase base con un campo de tipo Integer para almacenar la
información de código postal, y que otros programadores han creado clases derivadas que utilizan el campo
de código postal heredado. Suponga además que el campo de código postal almacena cinco dígitos y que la
oficina de correos ha ampliado los códigos postales con un guión y cuatro dígitos adicionales. En el peor de
los casos, podría modificar el campo en la clase base para almacenar una cadena de diez caracteres, pero
otros programadores tendrían que cambiar y volver a compilar las clases derivadas para utilizar el tamaño y
el tipo de datos nuevos.
La forma más segura de cambiar una clase base es simplemente agregar nuevos miembros. Por ejemplo,
podría agregar un nuevo campo para almacenar cuadro dígitos más en el ejemplo de código postal descrito
anteriormente. De esta forma, las aplicaciones cliente pueden actualizarse para que utilicen el nuevo campo
sin interrumpir las aplicaciones existentes. Esta posibilidad de extender clases base en una jerarquía de
herencia es una ventaja importante que no existe con interfaces.
Vea también
Conceptos
Cambios en el diseño de la clase base después de la implementación
Pág 132
Herencia y .NET Framework

Las aplicaciones de Visual Studio pueden utilizar muchas de las clases que se encuentran en .NET
Framework como clases base. Las clases de atributo, por ejemplo, siempre están basadas en la clase
Attribute. Otras clases base útiles de .NET Framework incluyen Component que se hereda para definir los
componentes y Exception que se hereda para definir las clases de excepción personalizadas.
.NET Framework es más que un origen para las clases base; garantiza la compatibilidad entre clases creadas
con lenguajes de programación diferentes. las clases de Visual Basic pueden heredar de las clases en
ensamblados creados por cualquier lenguaje admitido por Visual Studio. Las clases que crea en Visual Basic
también se pueden utilizar como clases base por otros lenguajes de programación de .NET Framework.
Vea también
Tareas
Conceptos

Se pueden derivar clases de Visual Basic de las clases Public de objetos COM, incluso si se crearon en
versiones anteriores de Visual Basic. Las propiedades y métodos de las clases heredadas de objetos COM
pueden ser invalidados o sobrecargados del mismo modo que las propiedades y métodos de cualquier otra
clase base. La herencia de objetos COM resulta útil cuando se tiene una biblioteca de clases que no se desea
volver a compilar.
En el procedimiento siguiente se muestra cómo usar Visual Basic 6.0 para crear un objeto COM que contiene
una clase y, a continuación, utilizar éste como clase base.
Nota:
Es posible que su equipo muestre nombres o ubicaciones diferentes para algunos de los elementos
de la interfaz de usuario de Visual Studio incluidos en las instrucciones siguientes. La edición de
Visual Studio que se tenga y la configuración que se utilice determinan estos elementos. Para
Para generar el objeto COM que se utiliza en este tutorial

1. En Visual Basic 6.0, abra un proyecto de archivo DLL ActiveX nuevo. Se crea un proyecto
denominado Project1. Tiene una clase denominada Class1.
2. En el Explorador de proyectos, haga clic con el botón secundario del mouse (ratón) en Project1 y, a
continuación, haga clic en Propiedades de Project1. Aparece el cuadro de diálogo Propiedades del
proyecto.
3. En la ficha General del cuadro de diálogo Propiedades del proyecto, escriba ComObject1 en el
campo Nombre de proyecto para cambiar el nombre del proyecto.
Pág 133
4. En el Explorador de proyectos, haga clic con el botón secundario del mouse en Class1 y, a
continuación, haga clic en Propiedades. Aparecerá la ventana Propiedades correspondiente a la
clase.
5. Establezca la propiedad Name en MathFunctions.
6. En el Explorador de proyectos, haga clic con el botón secundario del mouse en MathFunctions y, a
continuación, haga clic en Ver código. Aparece el Editor de código.
7. Agregue una variable local, que contendrá el valor de la propiedad:
Copiar código
' Local variable to hold property value
Private mvarProp1 As Integer
8. Agregue los procedimientos de propiedad Let y Get:
Copiar código
Public Property Let Prop1(ByVal vData As Integer)
'Used when assigning a value to the property.
mvarProp1 = vData
End Property
Public Property Get Prop1() As Integer
'Used when retrieving a property's value.
Prop1 = mvarProp1
End Property
9. Agregue una función:
Copiar código
Function AddNumbers( _
ByVal SomeNumber As Integer, _
ByVal AnotherNumber As Integer) _
As Integer
AddNumbers = SomeNumber + AnotherNumber

End Function
10. Cree y registre el objeto COM; para ello, haga clic en Crear ComObject1.dll en el menú Archivo.
Nota:
Aunque es posible exponer una clase creada con Visual Basic como un objeto COM, en realidad, no
se trata de un verdadero objeto COM y no se puede utilizar en este tutorial. Para obtener
información detallada, vea Interoperabilidad COM en aplicaciones .NET Framework.
Ensamblados de interoperabilidad
En el procedimiento siguiente va a crear un ensamblado de interoperabilidad que servirá como puente entre
el código no administrado (como un objeto COM) y el código administrado que utiliza Visual Studio. El
ensamblado de interoperabilidad creado por Visual Basic controla muchos de los aspectos del trabajo con
objetos COM, como el cálculo de referencias de interoperabilidad, el proceso de empaquetado de parámetros
y valores devueltos en los tipos de datos equivalentes enviados a objetos COM (o recibidos de objetos COM).
Pág 134
La referencia de la aplicación de Visual Basic apunta al ensamblado de interoperabilidad, no al objeto COM

real.
Para utilizar un objeto COM con Visual Basic 2005 y versiones posteriores
1. Abra un nuevo proyecto de aplicación para Windows de Visual Basic.
Aparece el cuadro de diálogo Agregar referencia.
3. En la ficha COM, haga doble clic en ComObject1 en la lista Nombre de componente y, a
continuación, haga clic en Aceptar.
4. En el menú Proyecto, haga clic en Agregar nuevo elemento.
Se abrirá el cuadro de diálogo Agregar nuevo elemento.
5. En el panel Plantillas, haga clic en Clase.
En el campo Nombre aparecerá el nombre de archivo predeterminado, Class1.vb. Cambie este
campo a MathClass.vb y haga clic en Agregar. Esto creará una clase denominada MathClass y
mostrará su código.
6. Agregue el código siguiente al principio de MathClass para heredar de la clase COM.
Visual Basic
Copiar código
' The inherited class is called MathFunctions in the base class,
' but the interop assembly appends the word Class to the name.
Inherits ComObject1.MathFunctionsClass
7. Sobrecargue el método público de la clase base agregando el código siguiente a MathClass:
Visual Basic
Copiar código
' This method overloads the method AddNumbers from the base class.
Overloads Function AddNumbers( _
As Integer
Return SomeNumber + AnotherNumber

End Function
8. Amplíe la clase heredada agregando el código siguiente a MathClass:
Visual Basic
Copiar código
' The following function extends the inherited class.
Pág 135
Function SubtractNumbers( _
As Integer
Return AnotherNumber - SomeNumber

End Function
La nueva clase hereda las propiedades de la clase base del objeto COM, sobrecarga un método y define otro
método para extender la clase.
Para probar la clase heredada

1. Agregue un botón al formulario de inicio y, a continuación, haga doble clic en él para ver su código.
2. En el procedimiento del controlador de eventos Click del botón, agregue el código siguiente para
crear una instancia de MathClass y llamar a los métodos sobrecargados:
Visual Basic
Copiar código
Dim Result1 As Short
Dim Result2 As Integer
Dim Result3 As Integer
Dim MathObject As New MathClass
Result1 = MathObject.AddNumbers(4S, 2S) ' Add two Shorts.
Result2 = MathObject.AddNumbers(4, 2) 'Add two Integers.
Result3 = MathObject.SubtractNumbers(2, 4) ' Subtract 2 from 4.
MathObject.Prop1 = 6 ' Set an inherited property.
MsgBox("Calling the AddNumbers method in the base class " & _

"using Short type numbers 4 and 2 = " & Result1)
MsgBox("Calling the overloaded AddNumbers method using " & _
"Integer type numbers 4 and 2 = " & Result2)
MsgBox("Calling the SubtractNumbers method " & _
"subtracting 2 from 4 = " & Result3)
MsgBox("The value of the inherited property is " & _
MathObject.Prop1)
3. Presione F5 para ejecutar el proyecto.

Cuando haga clic en el botón del formulario, se llamará primero al método AddNumbers con números de tipo
de datos Short y Visual Basic elegirá el método apropiado en la clase base. La segunda llamada a
AddNumbers se dirige al método de sobrecarga de MathClass. La tercera llamada llama al método
SubtractNumbers, que extiende la clase. Se establece el valor de la propiedad en la clase base y se
muestra dicho valor.
Pág 136
Pasos siguientes
Es posible que haya observado que la función AddNumbers sobrecargada parece tener el mismo tipo de
datos que el método heredado de la clase base del objeto COM. Esto se debe a que los argumentos y
parámetros del método de la clase base están definidos como enteros de 16 bits en Visual Basic 6.0, pero se
exponen como enteros de 16 bits de tipo Short en las versiones posteriores de Visual Basic. La nueva
función acepta enteros de 32 bits y sobrecarga la función de la clase base.
Al trabajar con objetos COM, es importante comprobar el tamaño y los tipos de datos de los parámetros. Por
ejemplo, al utilizar un objeto COM que acepta un objeto de colección de Visual Basic 6.0 como argumento,
no puede proporcionar una colección de una versión posterior de Visual Basic. Para obtener más información
sobre los controles de tipo de datos, vea Cambios en el lenguaje para usuarios de Visual Basic 6.0.
Es posible reemplazar propiedades y métodos heredados de clases COM, lo que significa que se puede
declarar una propiedad o método local que reemplace una propiedad o método heredado de una clase base
COM. Las reglas para reemplazar propiedades COM heredadas son similares a las reglas para reemplazar
otras propiedades y métodos, con las excepciones siguientes:
 Si reemplaza cualquier propiedad o método heredado de una clase COM, deberá reemplazar todas
las demás propiedades y métodos heredados.
 No es posible reemplazar las propiedades que utilizan parámetros ByRef.
Vea también
Tareas
Conceptos
Referencia
Short (Tipo de datos, Visual Basic)
Otros recursos
Interoperabilidad COM en aplicaciones .NET Framework

Casi todas las tareas que se pueden realizar con Visual Basic implican el uso de objetos, entre ellos algunas
entidades que normalmente no se suponen objetos, por ejemplo, cadenas y enteros. Todos los objetos de
Visual Basic se derivan y heredan métodos de una clase base llamada System..::.Object. La clase
System..::.Object proporciona una clase base común para todos los objetos de .NET Framework, lo que
garantiza la interoperabilidad de objetos desarrollada con Visual Studio. Las nuevas clases heredan
implícitamente la clase System..::.Object; no es necesario incluir explícitamente esta clase con una
instrucción Inherits.
De los métodos que los objetos heredan de System..::.Object, uno de los más útiles es GetType, que se
utiliza para devolver el tipo exacto del objeto actual.
Vea también
Conceptos
Referencia
Object
Pág 137
GetType
Cómo funcionan los métodos New y Finalize en una jerarquía

de clases
Cuando se crea una instancia de una clase, Common Language Runtime (CLR) intenta ejecutar un
procedimiento denominado New, si existe en ese objeto. New es un tipo de procedimiento llamado
constructor que se utiliza para inicializar nuevos objetos antes de que se ejecute cualquier otro código de un
objeto. Un constructor New puede utilizarse para abrir archivos, conectarse a bases de datos, inicializar
variables y realizar cualquier otra tarea necesaria antes de poder utilizar un objeto.
Cuando se crea una instancia de una clase derivada, se ejecuta primero el constructor Sub New de la clase
base, seguido de los constructores de las clases derivadas. Esto se debe a que la primera línea de código en
un constructor Sub New utiliza la sintaxis MyBase.New() para llamar al constructor de la clase situada
inmediatamente por encima en la jerarquía de clases. Después se llama al constructor Sub New para cada
clase de la jerarquía hasta llegar al constructor de la clase base. En este punto, se ejecuta el código del
constructor para la clase base, seguido del código en cada constructor de todas las clases derivadas,
ejecutándose en último lugar el código de las clases más derivadas.
Cuando un objeto deja de ser necesario, CLR llama al método Finalize para ese objeto antes de liberar su
memoria. El método Finalize se denomina destructor porque realiza tareas de limpieza, como guardar
información de estado, cerrar archivos y conexiones a bases de datos, y otras tareas que deben realizarse
antes de liberar el objeto.
Pág 138
Vea también
Conceptos
Polimorfismo
El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con
métodos o propiedades denominados de forma idéntica, que pueden utilizarse de manera intercambiable
mediante código cliente en tiempo de ejecución.
En esta sección
Cómo proporciona Visual Basic polimorfismo
Se ilustran distintos enfoques del polimorfismo.
Polimorfismo basado en la herencia
Se describe el uso de la herencia para conseguir el polimorfismo.
Polimorfismo basado en la interfaz
Se describe el uso de las interfaces para conseguir el polimorfismo.
Proporciona información sobre cuándo se debe utilizar la herencia en lugar de interfaces.
Pág 139
Cómo proporciona Visual Basic polimorfismo

Tradicionalmente, el polimorfismo en Visual Basic se realizaba mediante interfaces, y éstas aún pueden
usarse para este propósito. Sin embargo, ahora, Visual Basic proporciona la opción de usar la herencia para
conseguir el polimorfismo.
Como en otros temas de la programación orientada a objetos, la opción que debe utilizarse depende de los
requisitos específicos. En general, use la herencia cuando desee crear funcionalidad básica que las clases
derivadas puedan extender; use interfaces cuando varias implementaciones diferentes deban proporcionar
funcionalidad similar.
Vea también
Conceptos
Otros recursos

La mayoría de los sistemas de programación orientada a objetos proporcionan polimorfismo a través de la
herencia. El polimorfismo basado en la herencia implica definir métodos en una clase base y reemplazarlos
con nuevas implementaciones en clases derivadas.
Por ejemplo, podría definir una clase, BaseTax, que proporciona la funcionalidad básica para calcular los
impuestos sobre ventas en un estado. Las clases derivadas de BaseTax, como CountyTax o CityTax,
podrían implementar métodos como CalculateTax según las necesidades.
El polimorfismo se deriva del hecho de que se podría llamar al método CalculateTax de un objeto
perteneciente a cualquier clase derivada de BaseTax, sin saber a qué clase pertenecía el objeto.
El procedimiento TestPoly del siguiente ejemplo muestra el polimorfismo basado en la herencia:
Visual Basic
Copiar código
' %5.3 State tax
Const StateRate As Double = 0.053
' %2.8 City tax
Const CityRate As Double = 0.028
Public Class BaseTax
Overridable Function CalculateTax(ByVal Amount As Double) As Double
' Calculate state tax.
Return Amount * StateRate
End Function
End Class
Public Class CityTax

' This method calls a method in the base class
' and modifies the returned value.
Pág 140
Inherits BaseTax
Private BaseAmount As Double
Overrides Function CalculateTax(ByVal Amount As Double) As Double
' Some cities apply a tax to the total cost of purchases,
' including other taxes.
BaseAmount = MyBase.CalculateTax(Amount)
Return CityRate * (BaseAmount + Amount) + BaseAmount
End Function
End Class
Sub TestPoly()
Dim Item1 As New BaseTax
Dim Item2 As New CityTax
' $22.74 normal purchase.
ShowTax(Item1, 22.74)
' $22.74 city purchase.
ShowTax(Item2, 22.74)
End Sub
Sub ShowTax(ByVal Item As BaseTax, ByVal SaleAmount As Double)

' Item is declared as BaseTax, but you can
' pass an item of type CityTax instead.
Dim TaxAmount As Double
TaxAmount = Item.CalculateTax(SaleAmount)
MsgBox("The tax is: " & Format(TaxAmount, "C"))
End Sub
En este ejemplo, el procedimiento ShowTax acepta un parámetro denominado Item de tipo BaseTax, pero
también puede pasar cualquiera de las clases derivadas de la clase BaseTax, como CityTax. La ventaja de
este diseño es que se pueden agregar nuevas clases derivadas de la clase BaseTax sin cambiar el código
cliente en el procedimiento ShowTax.
Vea también
Conceptos
Otros recursos

Las interfaces proporcionan otro método de conseguir el polimorfismo en Visual Basic. Las interfaces
describen propiedades y métodos como clases, pero a diferencia de éstas, no pueden proporcionar ninguna
Pág 141
implementación. Las interfaces múltiples tienen la ventaja de permitir la evolución de los sistemas de
componentes de software sin interrumpir el código existente.
Para conseguir el polimorfismo con interfaces, se implementa una interfaz de diferentes formas en varias
clases distintas. Las aplicaciones cliente pueden utilizar la implementación nueva o la antigua, exactamente
de la misma manera. La ventaja del polimorfismo basado en interfaz es que no es necesario volver a
compilar aplicaciones cliente existentes para que funcionen con nuevas implementaciones de interfaz.
El siguiente ejemplo define una interfaz denominada Shape2 que se implementa en una clase denominada
RightTriangleClass2 y RectangleClass2. Un método denominado ProcessShape2 llama al método de
instancias CalculateArea de RightTriangleClass2 o RectangleClass2:
Visual Basic
Copiar código
Sub TestInterface()
Dim RectangleObject2 As New RectangleClass2
Dim RightTriangleObject2 As New RightTriangleClass2
ProcessShape2(RightTriangleObject2, 3, 14)
ProcessShape2(RectangleObject2, 3, 5)
End Sub
Sub ProcessShape2(ByVal Shape2 As Shape2, ByVal X As Double, _

ByVal Y As Double)
MsgBox("The area of the object is " _
& Shape2.CalculateArea(X, Y))
End Sub
Public Interface Shape2

Function CalculateArea(ByVal X As Double, ByVal Y As Double) As
Double
End Interface
Public Class RightTriangleClass2

Implements Shape2
Function CalculateArea(ByVal X As Double, _
ByVal Y As Double) As Double Implements Shape2.CalculateArea
' Calculate the area of a right triangle.
Return 0.5 * (X * Y)
End Function
End Class
Public Class RectangleClass2

Implements Shape2
Function CalculateArea(ByVal X As Double, _
ByVal Y As Double) As Double Implements Shape2.CalculateArea
Pág 142
' Calculate the area of a rectangle.

Return X * Y
End Function
End Class
Vea también
Tareas
Conceptos

Las jerarquías de herencia son más fáciles de implementar que de diseñar, por lo que es arriesgado
comenzar a codificar antes de identificar claramente las necesidades. La corrección de errores de diseño en
una jerarquía de clases tras la implementación puede requerir cambios que deshabilitan las aplicaciones
existentes. En esta sección se explican consideraciones del diseño de jerarquía de herencia y se proporciona
información que ayuda a evitar estos errores.
En esta sección
Consideraciones de diseño de jerarquías de clases para la extensibilidad
Se describe la forma de diseñar jerarquías de clases de modo que otros programadores pueden
actualizarlas o ampliarlas.
Consideraciones sobre la elección de niveles de acceso para métodos
Se describe el uso correcto de niveles de accesibilidad dentro de las clases.
Se explican los problemas los que se enfrentan los programadores al intentar hacer cambios en una
jerarquía de clases.
Se resume la forma de diseñar e implementar interfaces.
Consideraciones de diseño de jerarquías de clases para la

extensibilidad
Incluso las jerarquías de clases bien diseñadas necesitan evolucionar con el tiempo. Las opciones iniciales
que elija en el momento de diseñar una jerarquía de clases pueden simplificar su trabajo posteriormente.
Extender jerarquías de clases
En la siguiente lista se incluyen sugerencias para simplificar la extensión de las jerarquías de clases:
 Las jerarquías se definen desde lo general a lo específico. Defina las clases en cada nivel de una
jerarquía de herencia de la forma más genérica posible. Las clases derivadas pueden heredar,
reutilizar y extender métodos de clases base.
Pág 143
Por ejemplo, suponga que está diseñando un jerarquía de clases que modela el hardware del
equipo. Al comenzar a modelar los dispositivos de salida, podría definir clases denominadas
Display, Printer y File. Después podría definir las clases que implementan los métodos
definidos en las clases base. Por ejemplo, la clase LCDDisplay puede haber derivado de Display e
implementar un método denominado EnterPowerSaveMode.
 Defina los tipos de datos y el almacenamiento con generosidad a fin de evitar cambios difíciles
posteriormente. Por ejemplo, podría considerar el uso de una variable de tipo Long aunque los
datos actuales sólo requieran una variable estándar Integer.
 Exponga sólo los elementos que las clases derivadas necesiten. Los campos y métodos Private
reducen los conflictos de denominación y protegen a otros usuarios del uso de elementos que
pueden necesitar cambios posteriormente.
 Los miembros que sólo sean necesarios para las clases derivadas deben marcarse como Protected.
Esto garantiza que sólo las clases derivadas dependen de estos miembros y facilita la actualización
de estos miembros durante el desarrollo.
 Asegúrese de que los métodos de clase base no dependen de miembros Overridable cuya
funcionalidad pueden cambiar las clases herederas.
Vea también
Conceptos
Consideraciones sobre la elección de niveles de acceso para métodos
Referencia
MustInherit
MustOverride
Consideraciones sobre la elección de niveles de acceso para

métodos
Al aplicar los niveles de acceso óptimos a los miembros de una jerarquía de clases se facilita su
mantenimiento, ya que se puede controlar cómo se utilizarán dichos miembros.
Como norma general, deben declararse miembros de clase con modificadores que proporcionen la menor
cantidad posible de accesos. Al restringir el acceso a los miembros de clases se reducen los conflictos de
denominación y se impide que los métodos se utilicen de forma no deseada.
Los miembros de clase internos deben declararse como Private; el acceso a tales miembros sólo es posible
desde la clase en la que están definidos.
Los métodos que sólo se utilizan en una clase o en los descendientes de una clase deben utilizar el
modificador de acceso Protected. Un miembro Protected es accesible desde dentro de la clase en la que se
ha declarado, y desde dentro de cualquier clase derivada de la clase que declaró este miembro.
El acceso a los miembros de datos Friend puede realizarse desde fuera de una clase, pero sólo mediante los
módulos que forman parte del proyecto en que está definida la clase.
Los miembros de datos Public están siempre visibles y suelen utilizarse al final de una jerarquía de clases.
Vea también
Conceptos
Consideraciones de diseño de jerarquías de clases para la extensibilidad
Pág 144
Cambios en el diseño de la clase base después de la

implementación
Lo ideal sería que las jerarquías de clases nunca cambiaran después de su implementación, puesto que
incluso los pequeños cambios pueden tener consecuencias no deseadas. En realidad, estos cambios no
siempre pueden evitarse: los requisitos del producto pueden cambiar y las especificaciones de diseño a
veces omiten elementos clave. Una categoría de problemas de herencia se denomina el problema de
fragilidad de la clase base.
El problema de fragilidad de la clase base
El principal inconveniente de utilizar jerarquías de herencia es un problema denominado fragilidad de las
clases base. Para cambiar clases base suele ser necesario cambiar, volver a compilar y redistribuir la clase
base y todo el código de las clases derivadas. Este problema es aún mayor cuando son varios los autores de
la clase base y de las clases derivadas, puesto que cada uno puede denegar el acceso a su código fuente. En
el peor de los casos, un cliente podría utilizar sin darse cuenta la forma binaria compilada de una clase base
actualizada con el original y la versión binaria incompatible de las clases derivadas.
Los cambios en la clase base que pueden interrumpir las clases derivadas incluyen el reemplazar o cambiar
el tipo de datos de los miembros de la clase base.
Minimizar los problemas de fragilidad de la clase base
La mejor manera de evitar el problema de fragilidad de la clase base consiste en realizar los cambios sólo en
las clases derivadas. No obstante, esto no siempre es posible porque es necesario considerar todas las
posibilidades cuando se libera por primera vez la clase base; a pesar de todos los esfuerzos realizados en
este sentido, a veces los cambios imprevisibles en la clase base son inevitables.
El uso de clases MustInherit y métodos MustOverride ayuda a reducir los problemas de fragilidad de la
clase base, puesto que así los detalles de la implementación se trasladan a las clases derivadas y se reduce
la necesidad de cambios en la clase base. Una vez más, esto no siempre es posible, ni siquiera con el mejor
planeamiento.
Los miembros de datos sombreados en clases derivadas también sirven de ayuda, puesto que reducen los
conflictos de nomenclatura con los miembros de la clase base.
La forma más segura de extender la funcionalidad de una clase base consiste en agregar nuevos miembros.
Los nuevos miembros sólo podrán interrumpir una clase base si la clase derivada utiliza la palabra clave
Overloads para heredar métodos de la clase base e introducir nuevos métodos con el mismo nombre. Este
problema puede evitarse mediante la especificación explícita en la clase derivada de los métodos de la clase
base que desea heredar y redefiniendo esos métodos y delegando en ellos.
De alguna manera, todas las clases base tienen cierto grado de fragilidad. En el análisis final, el problema de
fragilidad de la clase base no se puede eliminar, pero sí minimizar mediante un diseño cuidadoso de las
jerarquías de clases que reduzca la necesidad de realizar cambios en la clase base y mediante la realización
de pruebas exhaustivas cuando tales cambios sean inevitables.
Vea también
Referencia
Shadows
Otros recursos
Pág 145

Los miembros compartidos son propiedades, procedimientos y campos que comparten todas las instancias
de una clase o estructura. En algunos lenguajes de programación estos elementos se denominan miembros
estáticos.
Campos y propiedades compartidos
Los campos y propiedades compartidos son útiles cuando se tiene información que forma parte de una clase,
pero que no es específica de ninguna instancia de una clase. Cuando se cambia el valor de un campo y
propiedad compartido, se cambia el valor asociado a la clase y todas las instancias de la clase.
Por otro lado, al cambiar el valor de un campo o propiedad no compartidos asociados a una instancia, el
valor de dicho campo o propiedad no se ve afectado en otras instancias de la clase. Los campos y
propiedades no compartidos existen de forma independiente en cada instancia de una clase.
De esta forma, los campos y propiedades compartidos se comportan como variables globales a las que sólo
se puede tener acceso desde instancias de una clase, o con cualificación del nombre de clase. Sin campos ni
propiedades compartidos, sería necesario utilizar variables en el nivel de módulo para conseguir el mismo
efecto. No obstante, las variables módulo pueden dificultar la comprensión y el mantenimiento de las clases.
Además, el uso de variables en el ámbito de módulo de esta forma infringe el concepto de encapsulación que
las clases representan.
Procedimientos compartidos
Los procedimientos compartidos son métodos de clase que no están asociados con una instancia específica
de una clase. Por ejemplo, el método Cos definido dentro de la clase Math es un método compartido. Se
puede llamar a un procedimiento compartido como un método de un objeto o directamente desde la clase.
Los procedimientos y las propiedades compartidos no tienen acceso a las instancias de la clase. Por este
motivo, en los métodos compartidos, sólo se permiten referencias calificadas a miembros de datos no
compartidos.
Nota:
No conviene escribir código desde el que se pueda tener acceso a un miembro compartido a través
de una instancia de la clase. Esto se debe a que el compilador no tiene en cuenta la calificación del
miembro compartido y lo trata como si se obtuviera acceso a él directamente a través de la clase.
En algunas situaciones, quizás desee que el objeto de cualificación ejecute cierto código y, por
tanto, el compilador de Visual Basic genere una advertencia de acceso a un miembro compartido a
través de una instancia de una clase. IntelliSense no muestra los miembros compartidos de una
instancia de la clase.
Ejemplo de miembros compartidos

En el ejemplo siguiente se crea un campo compartido, dos campos de instancias y un método compartido
para demostrar cómo funcionan los miembros compartidos en el código:
Visual Basic
Copiar código
Public Class Item
Public Shared Count As Integer = 1
Public Shared Sub ShareMethod()
MsgBox("Current value of Count: " & Count)
Pág 146
End Sub
Public Sub New(ByVal Name As String)

' Use Count to initialize SerialNumber.
Me.SerialNumber = Count
Me.Name = Name
' Increment the shared variable
Count += 1
End Sub
Public SerialNumber As Integer
Public Name As String
Public Sub InstanceMethod()
MsgBox("Information in the first object: " & _
Me.SerialNumber & vbTab & Me.Name)
End Sub
End Class
Sub TestShared()
' Create two instances of the class.
Dim part1 As New Item("keyboard")
Dim part2 As New Item("monitor")
part1.InstanceMethod()
part2.InstanceMethod()
Item.ShareMethod()
End Sub
Cuando ejecuta el procedimiento TestShared, se crean dos instancias de la clase. El constructor utiliza el
campo compartido Count para inicializar el campo de instancia SerialNumber y, a continuación, incrementa
Count. Esta técnica proporciona automáticamente a cada instancia un número de serie diferente.
Después de crear las dos instancias, el método de instancia InstanceMethod se llama en ambos objetos, y
también se llama al método compartido ShareMethod. El resultado es:
Information in the first object: 1 keyboard
Information in the second object: 2 monitor
Current value of the shared Count field: 3
Vea también
Conceptos
Referencia
Instrucción Dim (Visual Basic)
Cos
Otros recursos
Pág 147
Estructuras: tipos de datos propios
Enlace en tiempo de compilación y en tiempo de ejecución

El compilador de Visual Basic lleva a cabo un proceso denominado binding cuando se asigna un objeto a una
variable de objeto. Un objeto es de enlace en tiempo de compilación cuando se asigna a una variable que se
declara de un tipo de objeto específico. Los objetos de enlace en tiempo de compilación permiten al
compilador asignar memoria y realizar otras optimizaciones antes de que se ejecute la aplicación. Por
ejemplo, en el siguiente fragmento de código se declara que una variable es de tipo FileStream:
Visual Basic
Copiar código
' Create a variable to hold a new object.
Dim FS As System.IO.FileStream
' Assign a new object to the variable.
FS = New System.IO.FileStream("C:\tmp.txt", _
System.IO.FileMode.Open)
Como FileStream es un tipo de objeto específico, la instancia asignada a FS es de enlace en tiempo de

compilación.
Por el contrario, un objeto es de enlace en tiempo de ejecución cuando se asigna a una variable que se
declara de tipo Object. Los objetos de este tipo pueden contener referencias a cualquier objeto, pero
carecen de muchas de las ventajas de los objetos de enlace en tiempo de compilación. Por ejemplo, en el
siguiente fragmento de código se declara una variable de objeto para contener un objeto devuelto por la
función CreateObject:
Visual Basic
Copiar código
' To use this example, you must have Microsoft Excel installed on your
computer.
' Compile with Option Strict Off to allow late binding.
Sub TestLateBinding()
Dim xlApp As Object
Dim xlBook As Object
Dim xlSheet As Object
xlApp = CreateObject("Excel.Application")
' Late bind an instance of an Excel workbook.
xlBook = xlApp.Workbooks.Add
' Late bind an instance of an Excel worksheet.
xlSheet = xlBook.Worksheets(1)
xlSheet.Activate()
' Show the application.
xlSheet.Application.Visible = True
' Place some text in the second row of the sheet.
Pág 148
xlSheet.Cells(2, 2) = "This is column B row 2"

End Sub
Ventajas del enlace en tiempo de compilación

Siempre que sea posible, utilice objetos de enlace en tiempo de compilación, puesto que permiten al
compilador realizar importantes optimizaciones que producen aplicaciones más eficientes. Los objetos de
enlace en tiempo de compilación son bastante más rápidos y también facilitan la lectura y el mantenimiento
del código, ya que declaran exactamente qué clase de objetos se están utilizando. Otra ventaja del enlace en
tiempo de compilación consiste en que permite el uso de funciones útiles como la finalización automática de
código y la Ayuda dinámica, puesto que el entorno de desarrollo integrado (IDE) de Visual Studio puede
determinar exactamente el tipo de objeto con el que se está trabajando mientras se edita el código. El
enlace en tiempo de compilación reduce el número y la gravedad de los errores en tiempo de ejecución al
permitir que el compilador notifique los errores cuando se compila un programa.
Nota:
El enlace en tiempo de ejecución sólo puede utilizarse para obtener acceso a miembros de tipo
declarados como Public. Tener acceso a miembros declarados como Friend o Protected Friend
produce un error en tiempo de ejecución.
Vea también
Conceptos
Referencia
Object (Tipo de datos)
CreateObject (Función, Visual Basic)
Obtener información de clases en tiempo de ejecución

En algunos casos, es posible que necesite trabajar con variables definidas como tipo Object en lugar de
variables definidas como tipos de objeto más específicos. Las variables definidas como Object pueden
contener cualquier otro objeto de tipo, como tipos de datos Integer, Double u Object.
En esta sección
Determinar el tipo de objeto
Explica cómo determinar la clase a la que pertenece un objeto.
Llamar a una propiedad o método mediante un nombre de cadena
Explica paso a paso el proceso de especificación de argumentos por nombre en lugar de por
posición, al llamar a un método.
Describe los fundamentos de la programación orientada a objetos.
Pág 149

Las variables de objeto genéricas (es decir, variables declaradas como Object) pueden contener objetos de
cualquier clase. Al utilizar variables de tipo Object, puede necesitar tomar medidas diferentes basadas en la
clase del objeto; por ejemplo, algunos objetos no podrían admitir una propiedad determinada o método.
Visual Basic proporciona dos formas de determinar qué tipo de objeto se almacena en una variable de
objeto: la función TypeName y el operador TypeOf...Is.
TypeName y TypeOf…Is
La función TypeName devuelve una cadena y es la opción más conveniente si se necesita almacenar o
presentar el nombre de clase de un objeto, como se muestra en el fragmento de código siguiente:
Visual Basic
Copiar código
Dim Ctrl As Control = New TextBox
MsgBox(TypeName(Ctrl))
El operador TypeOf...Is es idóneo para comprobar el tipo de un objeto, puesto que es mucho más rápido
que una comparación de cadenas equivalente que utiliza TypeName. El fragmento de código siguiente usa
TypeOf...Is dentro de una instrucción If...Then...Else:
Visual Basic
Copiar código
If TypeOf Ctrl Is Button Then
MsgBox("The control is a button.")
End If
Use este método con precaución. El operador TypeOf...Is devuelve True si un objeto es de un tipo
específico o si se deriva de un tipo específico. Casi todas las tareas que se pueden realizar con Visual Basic
implican el uso de objetos, entre ellos algunos elementos que normalmente no se suponen objetos, por
ejemplo, cadenas y enteros. Estos objetos se derivan de Object y heredan métodos de ellos. Cuando se pasa
un Integer y se evalúa con Object, el operador TypeOf...Is devuelve True. El resultado del ejemplo
siguiente declara que el parámetro InParam es a la vez Object e Integer:
Visual Basic
Copiar código
Sub CheckType(ByVal InParam As Object)
' Both If statements evaluate to True when an
' Integer is passed to this procedure.
If TypeOf InParam Is Object Then
MsgBox("InParam is an Object")
End If
If TypeOf InParam Is Integer Then
MsgBox("InParam is an Integer")
End If
End Sub
Pág 150
En el ejemplo siguiente se utilizan TypeOf...Is y TypeName para determinar el tipo del objeto que se les
pasa en el argumento Ctrl. El procedimiento TestObject llama a ShowType con tres clases de controles
diferentes.
Para ejecutar el ejemplo

1. Cree un nuevo proyecto de aplicación para Windows y agregue al formulario un control Button, un
control CheckBox y un control RadioButton.
2. Llame al procedimiento TestObject desde el botón del formulario.
3. Agregue el código siguiente al formulario:
Visual Basic
Copiar código
Sub ShowType(ByVal Ctrl As Object)
'Use the TypeName function to display the class name as text.
MsgBox(TypeName(Ctrl))
'Use the TypeOf function to determine the object's type.
If TypeOf Ctrl Is Button Then
MsgBox("The control is a button.")
ElseIf TypeOf Ctrl Is CheckBox Then
MsgBox("The control is a check box.")
Else
MsgBox("The object is some other type of control.")
End If
End Sub
Protected Sub TestObject()

'Test the ShowType procedure with three kinds of objects.
ShowType(Me.Button1)
ShowType(Me.CheckBox1)
ShowType(Me.RadioButton1)
End Sub
Vea también
Conceptos
Llamar a una propiedad o método mediante un nombre de cadena
Referencia
Object (Tipo de datos)
TypeName (Función, Visual Basic)
Instrucción If...Then...Else (Visual Basic)
String (Tipo de datos, Visual Basic)
Integer (Tipo de datos, Visual Basic)
Otros recursos
Pág 151
Llamar a una propiedad o método mediante un nombre de

cadena
En la mayoría de los casos, puede descubrir las propiedades y métodos de un objeto en tiempo de diseño y
escribir código para controlarlos. No obstante, en algunos casos, puede que no conozca de antemano las
propiedades y los métodos de un objeto o que simplemente desee la flexibilidad de permitir a un usuario
final que especifique propiedades o ejecute métodos en tiempo de ejecución.
CallByName (Función)
Piense, por ejemplo, en una aplicación cliente que evalúe expresiones escritas por el usuario mediante el
paso de un operador a un componente COM. Suponga que está agregando constantemente funciones nuevas
al componente que requiere operadores nuevos. Cuando use las técnicas estándar de acceso a objetos, debe
compilar y distribuir de nuevo la aplicación cliente para poder utilizar los operadores nuevos. Para evitarlo,
puede utilizar la función CallByName para pasar los operadores nuevos como cadenas, sin modificar la
aplicación.
La función CallByName le permite utilizar una cadena para especificar una propiedad o método en tiempo
de ejecución. La firma para la función CallByName tiene el siguiente aspecto:
Resultado = CallByName(Objeto, nombreDeProcedimiento, tipoDeLlamada, Argumentos())
El primer argumento, Objeto, toma el nombre del objeto sobre el que desea actuar. El argumento
nombreDeProcedimiento toma una cadena que contiene el nombre del procedimiento de propiedad o método
que debe invocarse. El argumento tipoDeLlamada toma una constante que representa el tipo de
procedimiento que debe invocarse: un método (Microsoft.VisualBasic.CallType.Method), una lectura
de propiedad (Microsoft.VisualBasic.CallType.Get) o un conjunto de propiedades
(Microsoft.VisualBasic.CallType.Set). El argumento Argumentos, que es opcional, toma una matriz
de tipo Object que contiene los argumentos para el procedimiento.
Puede utilizar CallByName con clases en la solución actual, pero se utiliza más frecuentemente para
obtener acceso a objetos COM o a objetos de ensamblados de .NET Framework.
Suponga que agrega una referencia a un ensamblado que contiene una clase denominada MathClass, que
tiene una función nueva denominada SquareRoot, como se muestra en el siguiente código:
Visual Basic
Copiar código
Class MathClass
Function SquareRoot(ByVal X As Double) As Double
Return Math.Sqrt(X)
End Function
Function InverseSine(ByVal X As Double) As Double
Return Math.Atan(X / Math.Sqrt(-X * X + 1))
End Function
Pág 152
Function Acos(ByVal X As Double) As Double

Return Math.Atan(-X / Math.Sqrt(-X * X + 1)) + 2 * Math.Atan(1)
End Function
End Class
La aplicación podría utilizar controles de cuadro de texto para controlar qué método se va a llamar y sus
argumentos. Por ejemplo, si TextBox1 contiene la expresión que se va a evaluar y TextBox2 se utiliza para
escribir el nombre de la función, puede utilizar el siguiente código para invocar la función SquareRoot en la
expresión de TextBox1:
Visual Basic
Copiar código
Private Sub CallMath()
Dim Math As New MathClass
Me.TextBox1.Text = CStr(CallByName(Math, Me.TextBox2.Text, _
Microsoft.VisualBasic.CallType.Method, TextBox1.Text))
End Sub
Si escribe "64" en TextBox1, "SquareRoot" en TextBox2 y, a continuación, llama al procedimiento

CallMath, se evalúa la raíz cuadrada del número que aparece en TextBox1. El código del ejemplo invoca la
función SquareRoot (que toma una cadena con la expresión que se va a evaluar como argumento
requerido) y devuelve "8" en TextBox1 (la raíz cuadrada de 64). Si el usuario escribe una cadena no válida
en TextBox2, o si la cadena contiene el nombre de una propiedad en lugar de un método, o si el método
tiene un argumento necesario adicional, sin duda se producirá un error en tiempo de ejecución. Debe
agregar un código de control de errores sólido cuando use CallByName para prever estos errores u otros.
Nota:
Mientras que la función CallByName puede ser útil en algunas situaciones, debe sopesar su
utilidad frente a las implicaciones de rendimiento; el uso de CallByName para invocar un
procedimiento es un poco más lento que una llamada enlazada en tiempo de ejecución. Si está
invocando una función a la que se llama repetidamente, como ocurriría dentro de un bucle,
CallByName puede afectar de forma grave al rendimiento.
Vea también
Tareas
Cómo: Realizar varias acciones en un objeto
Conceptos
Referencia
CallByName (Función)
Otros recursos
Pág 153

Programación Orientada A Objetos en Visual Basic

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programación Orientada A Objetos en Visual Basic

Transféré par

Droits d'auteur :

Formats disponibles

Programación Orientada a Objetos en Visual Basic

Programación Orientada a Objetos en Visual Basic

 Cómo: Agregar eventos a una clase----------------------------------------------------------------82

Programación orientada a objetos en Visual Basic

Introducción a los objetos en Visual Basic

Sobrecarga, reemplazo y sombreado

Descripción de las clases

Explica los campos, propiedades y métodos que forman una clase.

Guía de programación de Visual Basic

Clases: como planos para objetos

Para obtener más información sobre herencias, consulte Fundamentos de la herencia.

Guía de programación de Visual Basic

Tutorial: Definir clases

Para definir una clase

8. Defina un método para la clase agregando el código siguiente:

' Capitalize the value of the property.

9. Defina un constructor parametrizado para la clase nueva agregando un procedimiento denominado

Para crear un botón que pruebe la clase

Para ejecutar la aplicación

Guía de programación de Visual Basic

Guía de programación de Visual Basic

Duración de los objetos: cómo se crean y destruyen

El recolector de elementos no utilizados de CLR no se deshace de los objetos no administrados (ni

Un destructor Finalize no debería producir excepciones porque la aplicación no puede controlarlas

Recolección de elementos no utilizados y el destructor Finalize

Guía de programación de Visual Basic

Cómo: Implementar el modelo DisposeFinalize (Visual Basic)

Private managedResource As System.ComponentModel.Component

Public Sub New()

Protected Overridable Overloads Sub Dispose( _

' Note that this is not thread safe.

Public Sub AnyOtherMethods()

#Region " IDisposable Support "

 Reemplace la declaración unManagedResource con declaraciones de objetos no administrados en

Guía de programación de Visual Basic

Utilizar constructores y destructores

Con frecuencia, los constructores están sobrecargados, como en el código siguiente:

' Keep track of when the object is disposed.

' This method disposes the base object's resources.

#Region " IDisposable Support "

Public Class Derived

' This method disposes the derived object's resources.

' The derived class does not have a Finalize method

Public Class BaseClass

Protected Overrides Sub Finalize()

Public Class ThisClass

Sub New(ByVal SomeValue As Integer)

Private ThisPropertyValue As Integer

Protected Overrides Sub Finalize()

' Do not add Overridable to this method.

Private disposed As Boolean = False

Protected Overridable Overloads Sub Dispose( _

' Call MyBase.Finalize if this is a derived class,

Guía de programación de Visual Basic

Propiedades, campos y métodos de clases

Guía de programación de Visual Basic

Cómo: Agregar campos y propiedades a una clase

Para agregar un campo a una clase

Para agregar una propiedad a una clase

6. En el siguiente ejemplo se declara una propiedad en una clase:

13. ' Return the value stored in the local variable.

Guía de programación de Visual Basic