Contenido
· Lección 1:
El sistema de tipos
o Tipos primitivos
o Variables y constantes
o Enumeraciones
o Arrays (matrices)
· Lección 2:
Clases y estructuras
o Clases
o Definir una clase
o Instanciar una clase
o Estructuras
o Accesibilidad
o Propiedades
o Interfaces
· Lección 3:
Manejo de excepciones
o Manejo de excepciones
· Lección 4:
Eventos y delegados
o Eventos
o Definir y producir eventos en una clase
o Delegados
o Definir un evento bien informado
· Lección 5:
Atributos
o Atributos
Ver vídeo 1 de esta introducción (Configurar el IDE - video en
Visual Studio 2005 válido para Visual Studio 2008)
Ver vídeo 2 de esta introducción (Crear un proyecto - video en
Visual Studio 2005 válido para Visual Studio 2008)
Introducción
En esta primera lección veremos los tipos de datos que .NET
Framework pone a
nuestra disposición y cómo tendremos que usarlos desde Visual
Basic 2008.
A continuación daremos un repaso a conceptos básicos o elementale
s sobre los
tipos de datos, que si bien nos serán familiares, es importante
que lo veamos para
poder comprender mejor cómo están definidos y organizados los
tipos de datos en
.NET.
Tipos de
datos de .NET
Visual Basic 2008 está totalmente integrado con .NET Framework,
por lo tanto, los
tipos de datos que podremos usar con este lenguaje serán los
definidos en este
"marco de trabajo", por este motivo vamos a empezar
usando algunas de las
definiciones que nos encontraremos al recorrer la documentación
que acomp aña a
este lenguaje de programación.
Los tipos de datos que podemos usar en Visual Basic 2008 son los
mismo tipos de
datos definidos en .NET Framework y por tanto están soportados por
todos los
lenguajes que usan esta tecnología. Estos tipos comunes se conocen
como el
Common Type System,
(CTS), que traducido viene a significar el sistema de tipos
comunes de .NET. El hecho de que los tipos de datos usados en
todos los
lenguajes .NET estén definidos por el propio Framework nos asegura
que
independientemente del lenguaje que estemos usando, siempre
utilizaremos el
mismo tipo interno de .NET, si bien cada lenguaje puede usar un
nombre (o alias)
para referirse a ellos, aunque lo importante es que siempre serán
los mismos
datos, independientemente de cómo se llame en cada lenguaje. Esto
es una gran
ventaja, ya que nos permite usarlos sin ningún tipo de problemas
para acceder a
ensamblados creados con otros lenguajes, siempre que esos
lenguajes sean
compatibles con los tipos de datos de .NET.
En los siguientes enlaces tenemos los temas a tratar en esta
primera lección del
módulo sobre las características del lenguaje Visual Basic 2008.
· Tipos
primitivos
o Sufijos o caracteres y símbolos identificadores para los
tipos
o Tipos por valor y tipos por referencia
o Inferencia de tipos
· Variables
y constantes
o Consejo para usar las constantes
o Declarar variables
o Declarar variables y asignar el valor inicial
o El tipo de datos Char
o Obligar a declarar las variables con el tipo de datos
o Aplicar Option Strict On a un fichero en particular
o Aplicar Option Stict On a todo el proyecto
o Más opciones aplicables a los proyectos
o Tipos anulables
o Tipos anónimos
· Enumeraciones:
Constantes agrupadas
o El nombre de los miembros de las enumeraciones
o Los valores de una enumeración no son simples números
· Arrays
(matrices)
o Declarar arrays
o Declarar e inicializar un array
o Cambiar el tamaño de un array
o Eliminar el contenido de un array
o Los arrays son tipos por referencia
Tipos
primitivos
Veamos en la siguiente tabla los tipos de datos definidos en .NET
Framework y los
alias utilizados en Visual Basic 2008.
.NET Framework VB 2008
System.Boolean Boolean
System.Byte Byte
System.Int16 Short
System.Int32 Integer
System.Int64 Long
System.Single Single
System.Double Double
System.Decimal Decimal
System.Char Char
System.String String
System.Object Object
System.DateTime Date
System.SByte SByte
System.UInt16 UShort
System.UInt32 UInteger
System.UInt64 ULong
Tabla 2.1. Tipos de datos y equivalencia entre lenguajes
Debemos tener en cuenta, al menos si el rendimiento es una de
nuestra
prioridades, que las cadenas en .NET son inmutables, es decir, una
vez que se han
creado no se pueden modificar y en caso de que queramos cambiar el
contenido,
.NET se encarga de desechar la anterior y crear una nueva cadena,
por tanto si
usamos las cadenas para realizar concatenaciones (unión de cadenas
para crear
una nueva), el rendimiento será muy bajo, si bien existe una clase
en .NET que es
ideal para estos casos y cuyo rendimiento es superior al tipo String: la clase
StringBuilder.
Las últimas filas mostradas en la tabla son tipos especiales que
si bien son parte
del sistema de tipos comunes (CTS) no forman parte de la Common Language
Specification (CLS), es
decir la especificación común para los lenguajes
"compatibles" con .NET, por tanto, si queremos crear
aplicaciones que puedan
interoperar con todos los lenguajes de .NET, esos tipos no debemos
usarlos co mo
valores de devolución de funciones ni como tipo de datos usado en
los argumentos
de las funciones, propiedades o procedimientos.
Los tipos mostrados en la tabla 2.1 son los tipos primitivos de
.NET y por
extensión de Visual Basic 2008, es decir son tipos
"elementales" para los cuales
cada lenguaje define su propia palabra clave equivalente con el
tipo definido en el
CTS de .NET Framework. Todos estos tipos primitivos podemos
usarlos tanto por
medio de los tipos propios de Visual Basic, los tipos definido s
en .NET o bien como
literales. Por ejemplo, podemos definir un número entero literal
indicándolo con el
sufijo I: 12345I
o bien asignándolo a un valor de tipo
Integer o a un tipo
Sytem.Int32 de .NET. La
única excepción de los tipos mostrados en la tabla 1 es el
tipo de datos Object, este es un caso especial del que nos ocuparemos en la
próxima lección.
Sufijos o caracteres y símbolos identificadores para los tipos
Cuando usamos valores literales numéricos en Visual Basic 2008, el
tipo de datos
que le asigna el compilador es el tipo Double, por tanto si nuestra intención es
indicar un tipo de datos diferente podemos indicarlos añadiendo una
letra como
sufijo al tipo, esto es algo que los más veteranos de VB6 ya
estarán
acostumbrados, e incluso los más noveles también, en Visual Basic
2008 algunos
de ellos se siguen usando, pero el tipo asociado es el equivalente
al de este nuevo
lenguaje (tal como se muestra en la tabla 1), por ejemplo para
indicar un valor
entero podemos usar la letra I o el signo %, de igual forma, un valor de tipo
entero largo (Long) lo podemos indicar usando L o &, en la siguiente tabla
podemos ver los caracteres o letra que podemos usar como sufijo en
un literal
numérico para que el compilador lo identifique sin ningún lugar a
dudas.
Tipo de datos Símbolo Carácter
Short N.A. S
Integer % I
Long & L
Single ! F
Double # R
Decimal @ D
UShort N.A. US
UInteger N.A. UI
ULong N.A. UL
Tabla 2.2. Sufijos para identificar los tipos de datos
El uso de estos caracteres nos puede resultar de utilidad
particularmente para los
tipos de datos que no se pueden convertir en un valor doble.
Nota:
Los sufijos pueden indicarse en minúsculas, mayúsculas o cualquier
combinación de mayúscula y minúscula.
Por ejemplo, el sufijo de un tipo ULong puede ser: UL, Ul, ul, uL,
LU,
Lu, lU o lu.
Para evitar confusiones, se recomienda siempre indicarlos en
mayúsculas, independientemente de que Visual Basic no haga ese
tipo de distinción.
Por ejemplo, si queremos asignar este valor literal a un tipo Decimal:
12345678901234567890, tal como vemos en la figura 1, el IDE de Visual Basic
2008 nos indicará que existe un error de desbordamiento (Overflow) ya que esa
cifra es muy grande para usarlo como valor Double, pero si le agregamos el sufijo
D o @ ya no habrá dudas de que estamos
tratando con un valor Decimal.
Figura 2.1. Error de desbordamiento al intentar asignar un valor
Double a
una variable Decimal
Tipos por valor y tipos por referencia
Los tipos de datos de .NET los podemos definir en dos grupos:
· Tipos por valor
· Tipos por referencia
Los tipos por valor son tipos de datos cuyo valor se almacena en
la pila o en la
memoria "cercana", como los numéricos que hemos visto.
Podemos decir que el
acceso al valor contenido en uno de estos tipos es directo, es
decir se almacena
directamente en la memoria reservada para ese tipo y cualquier
cambio que
hagamos lo haremos directamente sobre dicho valor, de igual forma
cuando
copiamos valores de un tipo por valor a otro, estaremos haciendo
copias
independientes.
Por otro lado, los tipos por referencia se almacenan en el
"monto" ( heap) o
memoria "lejana", a diferencia de los tipos por valor,
los tipos por ref erencia lo
único que almacenan es una referencia (o puntero) al valor
asignado. Si hacemos
copias de tipos por referencia, realmente lo que copiamos es la
referencia
propiamente dicha, pero no el contenido.
Estos dos casos los veremos en breve con más detalle.
Inferencia de tipos
Una de las características nuevas en Visual Basic 2008 es la
inferencia de tipos.
Se conoce como inferencia de tipos a la característica de Visual
Basic para inferir el
tipo de un dato al ser inicializado.
Para que la inferencia de tipos sea efectiva, deberemos activar la
opción Option
Infer a True, aunque por defecto, ese es el valor
que tiene el compilador de
Visual Basic. Sin embargo, si se hace una migración de una
aplicación de Visual
Basic a Visual Basic 2008, el valor de esta opción será False.
Supongamos por lo tanto, la siguiente declaración:
Dim datoDeclarado = 2008
En este ejemplo, la variable datoDeclarado, será una
variable de tipo Integer
(Int32).
Si deseamos cambiar el tipo de dato a un tipo Int64 por ejemplo, el compilador
nos devolverá un error. Así, el siguiente ejemplo no será válido en Visual Basic
2008 con la opción de inferencia activada:
Dim datoDeclarado = 2008
datoDeclarado
= Int64.MaxValue
Ahora bien, si cambiamos el valor de Option Infer a False, el mismo ejemplo
será correcto.
¿Dónde está la diferencia?.
En este último caso, el caso de tener desactivada la opción de
inferencia, la
declaración de la variable datoDeclarado nos indica que
es un tipo de dato Object
en su origen, y que al darle un valor Integer, ésta funciona como una variable
entera. Al cambiar su valor a Long, esta variable que es de tipo Object, cambia
sin problemas a valor Long.
En todo este proceso, hay un problema claro de rendimiento con
acciones de
boxing y unboxing que no serían necesarias si tipáramos la
variable con un tipo
concreto.
Eso es justamente lo que hace la opción Option Infer por nosotros.
Nos permite
declarar una variable con el tipo inferido, y ese tipo de datos se
mantiene dentro
de la aplicación, por lo que nos da la seguridad de que ese es su
tipo de dato, y
que ese tipo de dato no va a variar.
Ver vídeo 1 de esta lección (Tipos
de datos primitivos - video en
Visual Studio 2005 válido para Visual Studio 2008)
Ver vídeo 2 de esta lección (Tipos
por valor y por referencia - video
en Visual Studio 2005 válido para Visual Studio 2008)
Variables
y constantes
Disponer de todos estos tipos de datos no tendría ningún sen tido
si no pudiéramos
usarlos de alguna otra forma que de forma literal. Y aquí es donde
entran en juego
las variables y constantes, no vamos a contarte qué son y para que
sirven, salvo
en el caso de las constantes, ya que no todos los desarrolladores
las utilizamos de
la forma adecuada.
Consejo para usar las constantes
Siempre que tengamos que indicar un valor constante, ya sea para
indicar el
máximo o mínimo permitido en un rango de valores o para comprobar
el término
de un bucle, deberíamos usar una constante en lugar de un valor
literal, de esta
forma si ese valor lo usamos en varias partes de nuestro código,
si en un futuro
decidimos que dicho valor debe ser diferente, nos resultará más
fácil realizar un
solo cambio que cambiarlo en todos los sitios en los que lo hemos
usado, además
de que de esta forma nos aseguramos de que el cambio se realiza
adecuadamente
y no tendremos que preocuparnos de las consecuencias derivadas de
no haber
hecho el cambio en todos los sitios que deberíamos.
Las constantes se definen utilizando la instrucción Const seguida del nombre,
opcionalmente podemos indicar el tipo de datos y por último una
asignación con el
valor que tendrá. Como veremos en la siguiente sección, podemos
obligar a Visual
Basic 2008 a que en todas las constantes (y variables) que
declaremos, tengamos
que indicar el tipo de datos.
Para declarar una constante lo haremos de la siguiente forma:
Const maximo As Integer = 12345678
Declarar variables
La declaración de las variables en Visual Basic 2008 se hace por
medio de la
instrucción Dim seguida del nombre de la constante y del tipo de datos que
esta
contendrá. Con una misma instrucción Dim podemos declarar más de una variable,
incluso de tipos diferentes, tal y como veremos a continuación.
La siguiente línea de código declara una variable de tipo entero:
Dim i As Integer
Tal y como hemos comentado, también podemos declarar en una misma
línea más
de una variable:
Dim a, b, c As Integer
En este caso, las tres variables las estamos definiendo del mismo
tipo, que es el
indicado al final de la declaración.
Nota:
Como hemos comentado, en Visual Basic 2008 se pueden declarar las
constantes y variables sin necesidad de indicar el tipo de datos
que
contendrán, pero debido a que eso no es una buena práctica, a lo
largo de este curso siempre declararemos las variables y
constantes
con el tipo de datos adecuado a su uso.
Declarar variables y asignar el valor inicial
En Visual Basic 2008 también podemos inicializar una variable con
un valor
distinto al predeterminado, que en los tipos numéricos es un cero,
en las fechas es
el 1 de enero del año 1 a las doce de la madrugada ( #01/01/0001
12:00:00AM#) y en la
cadenas es un valor nulo (Nothing), para hacerlo,
simplemente tenemos que indicar ese valor, tal como veremos es muy
pareci do a
como se declaran las constantes. Por ejemplo:
Dim a As Integer = 10
En esa misma línea podemos declarar y asignar más variables, pero
todas deben
estar indicadas con el tipo de datos:
Dim a As Integer = 10, b As Integer = 25
Por supuesto, el tipo de datos puede ser cualquiera de los tipos
primitivos:
Dim a As Integer = 10, b As Integer = 25, s As String = "Hola"
Aunque para que el código sea más legible, y fácil de depurar, no
deberíamos
mezclar en una misma instrucción Dim más de un tipo de datos.
Nota:
Es importante saber que en las cadenas de Visual Basic 2008 el
valor
de una variable de tipo String no inicializada NO es una cadena
vacía,
sino un valor nulo (Nothing).
El tipo
de datos Char
En Visual Basic 2008 podemos declarar valores de tipo Char, este tipo de datos es
un carácter Unicode y podemos declararlo y asignarlo a un mismo
tiempo. El
problema con el que nos podemos encontrar es a la hora de indicar
un carácter
literal.
Podemos convertir un valor numérico en un carácter o bien podemos
convert ir un
carácter en su correspondiente valor numérico.
Dim c As Char
c = Chr(65)
Dim n As Byte
n = Asc(c)
En Visual Basic 2008 los tipos Char se pueden asignar a variables de tipo
String y
se hará una conversión automática sin necesidad de utilizar
funciones de
conversión.
Si nuestra intención es asignar un valor Char a una variable, además de la función
Chr, podemos hacerlo con un literal, ese
valor literal estará encerrado entre
comillas dobles, (al igual que una cadena), aunque para que
realmente sea un
carácter debemos agregarle una c justo después del cierre de las
comillas dobles:
Dim c As Char = "A"c
Obligar a declarar las variables con el tipo de datos
Visual Basic 2008 nos permite, (lamentablemente de forma
predeterminada),
utilizar las variables y constantes sin necesidad de indicar el
tipo de datos de
estas, pero, como comentábamos al principio, podemos obligar a que
nos avise
cuando no lo estamos haciendo, ya que como decíamos en la nota, es
una buena
costumbre indicar siempre
el tipo de datos que tendrán nuestras
variables y
constantes.
Esa obligatoriedad la podemos aplicar a todo el proyecto o a un
módulo en
particular, para ello tenemos que usar la instrucción Option Strict On,
una vez
indicado, se aplicará a todo el código, no solo a las declarac
iones de variables,
constantes o al tipo de datos devuelto por las funciones y
propiedades, sino
también a las conversiones y asignaciones entre diferentes tipos
de datos.
No debemos confundir Option Strict con Option Explicit, este último,
sirve para que
siempre tengamos que declarar todas las variables, mientras que el
primero lo que
hace es obligarnos a que esas declaraciones tengan un tipo de
datos.
Tanto una como la otra tienen dos estados: conectado o
desconectado
dependiendo de que agreguemos On u Off respectivamente.
Insistimos en la recomendación de que siempre debemos
"conectar" estas dos
opciones, si bien Option Explicit On ya
viene como valor por defecto, cosa que no
ocurre con Option
Strict, que por defecto está desconectado.
Aplicar Option Strict On a un fichero en particular
Cuando agregábamos un nuevo fichero a nuestro proyecto de Visual
Basic 2008 si
ya tenemos predefinida las opciones "estrictas", como es
el caso de Option Explicit
On, estas no se añadirán a dicho
fichero, (en un momento ve remos cómo hacerlo
para que siempre estén predefinidas), pero eso no significa que no
se aplique,
aunque siempre podemos escribir esas instrucciones (con el valor On al final) en
cada uno de los ficheros de código que agreguemos a nuestro
proyecto. Si nos
decidimos a añadirlas a los ficheros, esas líneas de código deben
aparecer al
principio del fichero y solamente pueden estar precedidas de
comentarios.
En la figura 2.1 mostrada en la lección anterior, tenemos una
captura del editor de
Visual Basic 2008 en la que hemos indicado que queremos tener
comprobación
estricta.
Aplicar Option Stict On a todo el proyecto
También podemos hacer que Option Strict funcione igual
que Option Explicit, es
decir, que esté activado a todo el proyecto, en este caso no
tendríam os que
indicarlo en cada uno de los ficheros de código que formen parte
de nuestro
proyecto, si bien solamente será aplicable a los que no tengan
esas instrucciones,
aclaremos esto último: si Option Strict (u Option Explicit) está
definido de forma
global al proyecto, podemos desactivarlo en cualquiera de los
ficheros, para ello
simplemente habría que usar esas declaraciones pero usando Off en lugar de On.
De igual forma, si ya está definido globalmente y lo indicamos
expresamente, no
se producirá ningún error. Lo importante aquí es saber que siempre
se usará el
estado indicado en cada fichero, independientemente de cómo lo
tengamos
definido a nivel de proyecto.
Para que siempre se usen estas asignaciones en todo el proyecto,
vamos a ver
cómo indicarlo en el entorno de Visual Basic 2008.
Abrimos Visual Studio 2008 y una vez que se haya cargado, (no hace
falta crear
ningún nuevo proyecto, de este detalle nos ocuparemos en breve),
seleccionamos
la opción Herramientas>Opciones... se mostrará un cuadro de diálogo y del
panel izquierdo seleccionamos la opción Proyectos y soluciones,
la expandimos
y seleccionamos Valores
predeterminados de VB y veremos ciertas opciones,
tal como podemos comprobar en la figura 2.2:
Figura 2.2. Opciones de proyectos (opciones mínimas)
De la lista despegable Option
Strict, seleccionamos On. Por defecto ya estarán
seleccionadas las opciones On
de Option Explicit y Binary de Option Compare,
por tanto no es necesario realizar ningún cambio más, para aceptar
los cambios y
cerrar el cuadro de diálogo, presionamos en el botón Aceptar.
Si en la ventana de opciones no aparece toda la configuración pod
emos hacer que
se muestren todas las disponibles. Para hacerlo, debemos marcar la
casilla que
está en la parte inferior izquierda en la que podemos leer: Mostrar todas las
configuraciones, al
seleccionar esa opción nos mostrará un número mayor de
opciones, tal como podemos ver en la figura 2.3:
Figura 2.3. Opciones de proyectos (todas las opciones)
Desde este momento el compilador de Visual Basic se volverá
estricto en todo lo
relacionado a las declaraciones de variables y conversiones, tal
como vemos en la
figura 2.4 al intentar declarar una variable sin indicar el tipo
de datos.
Figura 2.4. Aviso de Option Strict al declarar una variable sin
tipo
Nota:
Una de las ventajas del IDE (Integrated Development Environment,
entorno de desarrollo integrado) de Visual Basic 2008 es que nos
avisa al momento de cualquier fallo que cometamos al escribir el
código, este "pequeño" detalle, aunque alguna veces
puede llegar a
parecer fastidioso, nos facilita la escritura de código, ya que no
tenemos que esperar a realizar la compilación para que tengamos
constancia de esos fallos.
Más opciones aplicables a los proyectos
Aunque en estos módulos no trataremos a fondo el entorno de
desarrollo, ya que
la finalidad de este curso online es tratar más en el código
propiamente dicho,
vamos a mostrar otro de los sitios en los que podemos indicar
dónde indicar que
se haga una comprobación estricta de tipos y, como veremos,
también podremos
indicar algunas "nuevas peculiaridades" de Visual Basic
2008, todas ellas
relacionadas con el tema que estamos tratando.
Cuando tengamos un proyecto cargado en el IDE de Visual Studio
2008, (pronto
veremos cómo crear uno), podemos mostrar las propiedades del
proyecto, para
ello seleccionaremos del menú Proyecto la opción Propiedades de
<NombreDelProyecto> y
tendremos un cuadro de diálogo como el mostrado en
la figura 2.5.
Figura 2.5. Ficha Compilar de las opciones del proyecto actual
Seleccionando la ficha Compilar, además de las típicas opciones de Option
Strict, Option Explicit,Option Compare y Option Infer, (estas
asignaciones
solo serán efectivas para el proyecto actual), tendremos cómo
queremos que
reaccione el compilador si se cumple algunas de las condiciones
indicadas. Entre
esas condiciones, tenemos algo que muchos desarrolladores de
Visual Basic
siempre hemos querido tener: Que nos avise cuando una variable la
hemos
declarado pero no la utilizamos (Variable local no utilizada).
Al tener marcada
esta opción (normalmente como una Advertencia), si hemos declarado
una
variable y no la usamos en el código, (siempre que no l e hayamos
asignado un
valor al declararla), nos avisará, tal como podemos ver en la
figura 2.6:
Figura 2.6. Aviso de variable no usada
Tipos anulables
Otra interesantísima característica de Visual Basic 2008 que
conviene conocer, es
lo que se denominan tipos anulables.
Los tipos anulables no son nuevos en Visual Basic, de hecho su
origen lo
encontramos en Visual Studio 2005, aunque eso sí, implementando la
clase
Nullable(Of T).
Con Visual Basic 2008 no es necesario declarar ninguna clase para
implementar
tipos anulables dentro de nuestras aplicaciones, y podemos
declararlos de forma
directa.
Un tipo de dato anulable nos permitirá declarar una variable que
podrá tener un
tipo de dato nulo.
Si hemos estado atentos hasta ahora, hemos podido ver que las
variables
numéricas por ejemplo, se inicializan a 0.
Si quisiéramos por la razón que fuera, declarar esa variable como
nula para sa ber
si en un determinado momento ha cambiado de valor o cualquier otra
acción,
deberíamos utilizar los tipos de datos anulables, o bien, utilizar
técnicas más
rudimentarias como una variable de tipo Boolean que nos permitiera saber si ha
habido un cambio de valor en una variable, sin embargo, coincidirá
conmigo en
que el uso de un tipo de datos anulable es más natural y directo.
De esta forma, podríamos trabajar con tipos de datos anulables o
que los
declararemos como nulos.
A continuación veremos un ejemplo:
Dim valor As Integer?
Para acceder al valor de un tipo anulable, podríamos hacerlo de la
forma habitual,
ahora bien, si no sabemos si el valor es nulo o no, podríamos
acceder a su valor
preguntando por él mediante la propiedad HasValue. La propiedad Value nos
indicará también, el valor de esa variable.
Un ejemplo que aclare esta explicación es el que podemos ver a
continuación:
Dim valor As Integer?
If Valor.HasValue Then
MessageBox.Show(valor.Value)
End If
Otra característica de los tipos anulables es la posibilidad de
utilizar la función
GetValueOrDefault.
Esta función nos permitirá acceder al valor de la variable si no
es nulo, y al valor
que le indiquemos si es nulo.
Un breve ejemplo de este uso es el que se indica a continuación:
Dim valor As Integer?
valor =
2008
MessageBox.Show(valor.GetValueOrDefault(2012))
End If
En este ejemplo, el compilador nos devolvería el valor 2008, ya que
GetValueOrDefault sabe
que la variable no posee un valor nulo y que por lo tanto,
debe obtener el valor no nulo de la variable anulable.
En el caso de que no hubiéramos dado ningún valor a la variable,
la aplicación
obtendría el valor 2012.
Tipos anónimos
Esta característica de Visual Basic 2008, nos permite declarar los
tipos de datos de
forma implícita desde el código de nuestras aplicaciones.
Un ejemplo práctico de declaración de tipos anónimos es el
siguiente:
Dim declaracion = New With {.Nombre = "Carlos", .Edad = 27}
MessageBox.Show(String.Format("{0}
tiene {1} años", _
declaracion.Nombre,
declaracion.Edad))
Como podemos ver en el ejemplo anterior, hemos declarado un objeto
al que no
hemos indicado ningún tipo de dato concreto, pero a la hora de
crear ese objeto,
hemos creado implícitamente un miembro Nombre y un miembro Edad.
Ver vídeo 1 de esta lección (Declarar
variables) - video en Visual
Studio 2005 válido para Visual Studio 2008
Ver vídeo 2 de esta lección (Definir
constantes) - video en Visual
Studio 2005 válido para Visual Studio 2008
Enumeraciones:
Constantes agrupadas
Una enumeración es una serie de constantes que están relacionadas
entre sí. La
utilidad de las enumeraciones es más manifiesta cuando queremos
manejar una
serie de valores constantes con nombre, es decir, podemos indicar
un valor, pero
en lugar de usar un literal numérico, usamos un nombre, ese nombre
es, al fin y al
cabo, una constante que tiene un valor numérico.
En Visual Basic 2008 las enumeraciones pueden ser de cualquier
tipo numérico
integral, incluso enteros sin signo, aunque el valor predefinido
es el tipo Integer.
Podemos declarar una enumeración de varias formas:
1- Sin indicar el tipo de datos, por tanto serán de tipo Integer:
Enum Colores
Rojo
Verde
Azul
End Enum
2- Concretando explícitamente el tipo de datos que realmente
tendrá:
Enum Colores As Long
Rojo
Verde
Azul
End Enum
En este segundo caso, el valor máximo que podemos asignar a los miembros
de
una enumeración será el que pueda contener un tipo de datos Long.
3- Indicando el atributo FlagsAttibute, (realmente
no hace falta indicar el sufijo
Attribute cuando usamos
los atributos) de esta forma podremos usar los valores
de la enumeración para indicar valores que se pueden
"sumar" o complementar
entre sí, pero sin perder el nombre, en breve veremos qué
significa esto de "no
perder el nombre".
<Flags()>
_
Enum Colores As Byte
Rojo = 1
Verde = 2
Azul = 4
End Enum
Nota:
Los atributos los veremos con más detalle en otra lección de este
mismo módulo.
