Cmo... en VB .

NET
Cdigo de ejemplo de recordatorio para
mentes olvidadizas (como la ma)

Conceptos bsicos: Tipos de ficheros o
mdulos que se pueden usar en VB.NET

Aunque los ficheros de cdigo usados para compilar programas para Visual
Basic .NET pueden tener cualquier extensin, es recomendable usar la "nueva"
extensin .vb; a nuestro criterio queda el usar otras extensiones.
Realmente lo quen interesa es el contenido del fichero. Antes cada tipo de
fichero tena un significado para el entorno integrado del Visual Basic, pero
ahora ya no lo tiene... aunque el diseador de formularios da por hecho que
los listados de Visual Basic sean los que tengan la extensin .vb y los de c# los
que tengan la extensin .cs.

Como te deca, lo realmente importante es el contenido del fichero en cuestin,
dentro de ese fichero pueden existir varias clases, diferentes Namespaces y
formularios, etc. Vamos a ver que podemos usar, cmo y cuando es
recomendable usarlo:
Namespace:
Segn la ayuda del NGWS SDK (o .NET SDK), un Namespace es la forma
de identificar una serie de clases, estructuras de datos, etc. que hacen
referencia a un mismo tema. La nomenclatura usada, (o la
recomendada), es: NombreCompaa.TipoTecnologa
De esta forma evitaremos que hay duplicidad en los nombres asignados
a un Namespace, por ejemplo: Microsoft.VisualBasic har referencia a
las clases, datos, etc. que propone Microsoft para VisualBasic...
Todo cdigo usado en cualquier componente para .NET debe residir en,
como mnimo, un Namespace, dentro de ese Namespace incluiremos
clases y datos relacionados con la funcionalidad que pretendemos que
dicho "espacio" tenga; de esta forma, ser ms fcil "trocear" el cdigo
de forma que slo usemos el cdigo que realmente necesitemos y
tambin servir para hacer ms fcil la localizacin de dicho cdigo,
sobre todo si lo tenemos compilado en forma de librera (DLL). Si no te
has enterado... ya lo comprenders conforme vayamos viendo cdigo de
ejemplo.

Todo el cdigo declarado en un Namespace es visible dentro del mismo
Namespace, se hayan declarado como se hayan declarado, es decir: una
clase declarada Private ser visible en todas las clases declaradas dentro
del mismo Namespace. NO se pueden declarar variables a "nivel" de
Namespace, para esos casos, podemos usar Module:
Module:
El cdigo declarado en un Module es parecido a lo que hasta ahora se
codificaba en ficheros con la extensin .bas. Todas las variables,
procedimientos e incluso clases declaradas en una seccin Module ser
visible en el mismo Namespace en el que se ha declarado dicho Module.
Tambin sern accesibles a todo cdigo que IMPORTE dicho Namespace,
usando: Imports NombreDelNamespace.

Se puede usar Module para los casos en que necesitemos usar variables
y constantes globales al Namespace y sobre todo para crear un punto de
ejecucin de nuestro programa, (osea, por donde queramos que nuestro
cdigo empiece a ejecutarse), declarando un procedimiento que se llame
Main y sea pblico. Pero si no queremos tener un Module para declarar
slo el procedimiento Main, podemos tener en una clase un
procedimiento con ese nombre, aunque en esta ocasin adems de
pblico debe estar declarado como Shared: Shared Public Sub Main()
Nota: Slo puede existir un procedimiento Main en cada ejecutable.
Class:
Las clases son los objetos que podemos crear en Visual Basic, y no es
una excepcin en VB.NET, la nica diferencia es que no es necesario que
cada clase resida en un fichero diferente, en un mismo fichero .vb puede
haber tantas clases como necesitemos.
Salvo Namespace, tanto Module como Class pueden ser Public, Private,
Protected, Friend o Protected Friend.
Namespace siempre es Public y no permite usar un modificador de
"visibilidad".
En caso de no indicarse el "modificador", se entiende que est declarado como
Friend, salvo en el caso de que sean variables, en cuyo caso, sern Private. Por
tanto, es recomendable usar siempre el modificador.
Los miembros declarados como Private, slo sern accesibles en el Namespace
en el que se declararon.

Cmo... Compilar un formulario creado con
Win Forms
vbc file_principal.vb [file2.vb... fileN.vb] /r:System.dll
/r:System.WinForms.dll /r:System.Drawing.dll

Nota:
En la versin definitiva, tendrs que cambiar
System.WinForms.dll por
System.Windows.Forms.dll
El nombre del ejecutable ser el del primer fichero, si se quiere indicar otro:
indicarlo con el parmetro /out, por ejemplo: /out:Nombre.exe


Para indicarle el tipo de ejecutable (o fichero compilado), se usar
/target: o /t: y uno de estos parmetros:

/target:exe Crea un .exe del tipo consola.
/target:library Crea una librera de cdigo (DLL).
/target:module Crea un mdulo.
/target:winexe Crea un ejecutable de Windows. Este es el valor por defecto,
osea: cuando no se especifica la opcion target.

Cmo... Trabajar con un ListBox y otros
controles que contienen lista de elementos

Un ListBox es del tipo de control que contiene una lista de elementos, aqu
veremos cmo manejar y acceder a los elementos, aadirlos, borrarlos, etc.
Esto tambin es aplicable al ComboBox.
Borrar el contenido de un ListBox: ListBox1.Items.Clear

Aadir elementos a un ListBox: ListBox1.Items.Add(cadena)

Tomar un elemento de un ListBox (cadena):
ListBox1.GetItemText(Elemento)
Elemento ser un Item, no un valor numrico:
ListBox1.GetItemText(ListBox1.Items(ndice))

Tambin podemos tomar el texto de un elemento mediante un ndice
numrico usando algo como:
s = ListBox1.Items(ndice).ToString()


Tomar el elemento 'Clickeado' y asignarlo a un TextBox:
Esto ser vlido para los ListBox, pero no para los ComboBoxes

Protected Sub ListBox1_Click(ByVal sender
As System.Object, ByVal e As System.EventArgs)
With ListBox1
TextBox1.Text =
.GetItemText(.SelectedItem)
End With
End Sub
Saber cuando cambia el elemento seleccionado:
En el caso de los combos se puede usar este evento cuando se
selecciona de la lista desplegable (en ese caso el evento Click no
funciona...) El evento en cuestin es: SelectedIndexChanged

Para saber el ndice del item seleccionado: i = .SelectedIndex
Tambin para indicar el ndice seleccionado: .SelectedIndex = 0

Borrar un elemento de la lista: .Items.Remove(i)


Cmo... Manejar un array

Todos los arrays en VB.NET empiezan con el ndice cero. Al declarar un array,
el nmero usado, indicar el nmero de elementos, stos irn desde 0 hasta el
nmero menos uno:
Dim unArray(3) As String ' Se declara un array de 3 elementos del tipo
cadena, de 0 a 2
Crear una array de N elementos del tipo indicado (los elementos
sern de 0 a N-1): Dim unArray(7) As String

Asignar un valor al array: unArray(0) = "Elemento 0"

Saber el nmero de elementos del array: x = unArray.Length

Redimensionar el array, (previamente debe estar declarado con
Dim): Se puede hacer de estas dos formas:
Redim unArray(x+1) ' Se redimensiona, pero no se mantiene el
contenido anterior.
Redim Preserve unArray(x+1) ' Se redimensiona y se mantiene el
contenido anterior.

Asignar un valor al array: unArray(0) = "Elemento 0"

Recorrer los elementos de un array usando For Each...
Los elementos de un array se consideran objetos, a pesar de que
podamos crearla del tipo String, por poner un caso.
Por tanto, para recorrer los elementos de un array usando For Each,
haremos lo siguiente:
' En los arrays, para usar For Each, deben ser
Objetos
Dim t As Object
Dim s As String
Dim i As Integer

' Esta comprobacin es conveniente, ya que si
el Array an no est dimensionado, dar error.
Try
' simplemente para saber si se produce
error
i = m_Array.Length
Catch
' Si se produce un error, asignamos el
valor cero, que ms abajo indicar si el array
contien datos o no
i = 0
End Try
'
If i = 0 Then
s = s & "No hay datos en el array" & vbCrLf
Else
i = 0
For Each t In m_Array
i += 1 ' igual que i = i + 1
s = s & t.ToString & " (" & i.ToString
& ")" & vbCrLf
Next
End If




Cmo... Convertir un nmero en un
carcter

Usando CChar(x) podemos convertir un nmero en un carcter, al estilo de
Chr$(x) del VB pre.NET
De esta forma, podemos crear constantes al estilo de las del Visual Basic:
Private Const vbCr As Char = CChar(13)
Private Const vbLf As Char = CChar(10)
Private Const vbCrLf As String = vbCr & vbLf
Private Const vbTab As Char = CChar(9)

Nota:
En la versin definitiva CChar() slo acepta valores de
tipo String.
Para convertir un nmero en un tipo Char, se puede
usar Chr() o ChrW()


Cmo... usar colecciones mejoradas:
ArrayList

Las colecciones ArrayList son como las colecciones de Visual Basic, pero
bastante mejoradas, veamos algunas de las propiedades y mtodos, ya que
considero que este tipo de lista (o coleccin) puede ser de gran utilidad.
Nota: Para poder usarla hay que indicar: Imports System.Collections.
Propiedades:
Capacity: Asigna o devuelve el nmero mximo de elementos que
contendr el ArrayList.
Este valor siempre ser igual o mayor que el devuelto por Count. Si al
aadir un nuevo elemento, Count fuese mayor que Capacity, la
capacidad del array interno se duplicara para que se pudiesen aadir
nuevos elementos. Si se asigna directamente un valor, el array interno
se adaptara a ese valor.
Count: Devuelve el nmero de elementos actuales.
Item: Asigna o devuelve el elemento indicado.

Mtodos:
Add: Aade un nuevo elemento al final del array (o coleccin).
BinarySearch: Realiza una bsqueda binaria en una lista ordenada.
Clear: Borra los elementos de la lista.
Clone: Hace una copia de la lista.
Contains: Determina si un elemento est contenido en la lista.
CopyTo: Copia toda o una parte de la lista en un array unidimensional.
Equals: Determina si el objeto especificado es igual al objeto actual.
FixedSize: Devuelve un ArrayList en la que slo se pueden modificar
elementos, no aadirlos o eliminarlos. La lista devuelta es lo que se
llama list wrapper osea una lista que apunta a la lista original, por
tanto cualquier cambio realizado en esa lista, se reflejarn en la
original.
GetRange: Devuelve una lista con los elementos indicados.
IndexOf: Devuelve el ndice de la primera ocurrencia del elemento
indicado.
Insert: Inserta un elemento en el ndice indicado.
InsertRange: Inserta los elementos de una coleccin en el ndice
indicado.
LastIndexOf: Devuelve el ndice de la ltima ocurrencia del elemento
indicado.
ReadOnly: Devuelve un list wrapper con acceso de slo lectura.
Remove: Elimina el elemento indicado, (el elemento debe ser un objeto
de los contenidos en la lista).
RemoveAt: Elimina el elemento del ndice especificado.
RemoveRange: Elimina el rango indicado.
Repeat: Devuelve un ArrayList cuyos elementos son copias del objeto
indicado. Se indicar el objeto a copiar y el nmero de veces.
Reverse: Invierte el orden de los elementos de la lista o del rango
indicado.
SetRange: Copia los elementos de una coleccin a partir del ndice
indicado.
Sort: Clasifica los elementos de la lista.
ToArray: Copia los elemetos de la lista en un nuevo Array u objeto.
ToString: Devuelve la representacin del objeto como una cadena.
Dependiendo de la implementacin de este mtodo, puede devolver el
nombre completo de la clase o bien la representacin del valor.
TrimToSize: Asigna la capacidad de la lista al nmero de elementos
que tiene actualmente, til cuando sabemos que no vamos a modificar
el nmero de elementos. Para borrar totalmente los elementos de un
ArrayList, llamar antes al mtodo Clear y despus a TrimToSize.

Cmo... saber cuando usar Protected,
Private, etc.

Estos modificadores de declaraciones de clases, mtodos, propiedades y
variables, se usarn cuando queramos modificar el "alcance" de visibilidad de
dichos miembros.
Private:
Un miembro declarado como Privado, slo es accesible en la clase en la
que se ha declarado.

Protected:
Un miembro declarado como Protected es accesible en la clase en la
que se ha declarado y en las que deriven de ella.

Friend:
Un miembro declarado como Friend es visible en:
- la clase en la que se ha declarado,
- el Namespace en el que est dicha clase,
- en el mismo programa en el que est la declaracin; por ejemplo, si
se compilan varios ficheros con distintos Namespaces en un mismo
programa (ejecutable o componente).

Protected Friend:
Idem que Friend, adems de ser visible en las clases derivadas.

Public:
Visible por todo el mundo.


Osea, que si queremos crear miembros de la clase que slo sean
visibles en esa clase, usaremos Private (como hasta ahora).
En el caso de que nos interese que las clases derivadas puedan acceder
a esos miembros, pero no nos interesa que el resto del Namespace o
mdulo en el que est declarado pueda acceder, entonces usaremos
Protected.
Si lo que queremos es que determinados miembros sean visibles slo
en el Namespace en el que se ha creado la clase o en el mismo
programa en el que est la declaracin, habr que declararlos como
Friend.
Y si adems de que sea visible en el Namespace o programa, queremos
que tambin sean visibles en las clases derivadas, en ese caso habr
que declararlo como: Protected Friend.
Por ltimo, si no nos importa que esos miembros de nuestra clase sean
vistos por cualquier clase, est o no en el mismo Namespace, mdulo o
lo que sea... entonces la declararemos como Public.


Nota: Si se declara una clase que se deriva de otra, el modificador
debe ser igual o ms restrictivo que la clase heredada. Por ejemplo, si
Clase1 se declar como Friend, la siguiente declaracin producira un
error: Public Class Clase2 : Inherits Clase1, ya que los miembros de
Clase1 no pueden "promoverse" a pblicos.

Cmo... declarar variables y la visibilidad de
las mismas.
Aqu veremos cmo se declaran variables (y objetos) en la nueva versin de
Visual Basic, tambin veremos cmo ha cambiado el "alcance" o visibilidad de
las variables.
Aunque haba leido por ah que ya no se pueden declarar variables
Pblicas en clases para que se conviertan automticamente en
Propiedades... siguen funcionando como si lo fuesen... al menos se
pueden asignar valores y devolverlos cuando queramos. Es decir,
dentro de la clase, declaras una variable como pblica y esa variable se
convierte en una propiedad de lectura/escritura, es decir que se le
pueden asignar valores y puede devolver el anteriormente almacenado.
An as, esta no es la forma "deseable" de declarar una propiedad en
una clase... ni en la nueva versin de Visual Basic ni en las anteriores...


Ahora la visibilidad de las variables o el alcance que tienen pueden ser
locales a cada bloque de cdigo:
Por ejemplo, si dentro de un bucle For declaramos una variable, esa
variable es visible dentro del mismo bucle FOR, pero ser "desechada"
cuando se abandone el bucle. Lo mismo ocurre con el resto de
"bloques": IF...THEN...ELSE...END IF, DO...LOOP, SELECT...END
SELECT, etc. Lo que no podemos tener es una variable con el mismo
nombre fuera y dentro de un bloque de cdigo.


A diferencia de las versiones anteriores de Visual Basic, en esta nueva
versin no se pueden declarar variables del tipo STATIC, es decir,
variables que se declaraban dentro de un procedimiento y que
mantenan el valor entre diferentes llamadas al mismo procedimiento,
(cuando un procedimiento acaba, se desechan todas las variables
declaradas en dicho procedimiento)


Al declarar una variable podemos asignarle directamente un valor:
Dim N As Integer = 10, incluso el valor devuelto por una funcin: Dim S
As String = tClase1.Nombre()
Los objetos tambin se pueden declarar para que sean iniciadas en la
propia declaracin: Dim tClase1 As New Clase1
A diferencia de las versiones anteriores, esto no significa una
"sobrecarga" de cdigo, es decir: en las versiones anteriores de Visual
Basic, si una clase se declaraba con New, el compilador tena que
comprobar cada vez que se usaba esa clase si ya estaba creada o no,
en caso de no estarlo, se creaba una nueva instancia... lo cual
significaba un cdigo extra que insertaba de forma automtica el
compilador. La forma en que el VB.NET declara las variables es igual
que si en las versiones anteriores hicieramos esto:
Dim tClase1 As Clase1
Set tClase1 = New Clase1
Cosa que an podemos seguir haciendo, con la salvedad de que ya no
se usa SET para asignar objetos a una variable.

Los modificadores de visibilidad de las variables, son los mismos que
para los mtodos... ver lo que dice la seccin anterior.

Cmo... declarar Propiedades y Mtodos en
las clases.
Los mtodos de una clase se declaran de la misma forma que en
versiones anteriores de Visual Basic, ya sabes que un mtodo es un
procedimiento Function o Sub, segn queramos que devuelva o no un
valor.
Como sabrs, una propiedad puede usarse para asignar o devolver un
valor, en las versiones anteriores a la 7 (vb.net), se declaraban como
Property Get, Property Set y Property Let. En esta nueva versin de
Visual Basic, las propiedades se declaran de forma diferente, ya que no
existen procedimientos separados para cada tipo de accin a realizar
por una propiedad.
Adems del modificador de visibilidad: Public, Private, etc. se puede
indicar que un propiedad es la propiedad por defecto, si se indica
Default, aunque las propiedades por defecto deben aceptar
parmetros, si no es as, no nos permitir que la declaremos como
Default. Creo que esto se debe a que las asignaciones de clases se
hacen sin usar Set y en caso de que se hiciese esta asignacin: Clase2
= Clase1, se creara una referencia de la Clase1 en la Clase2, no se
asignara el valor de la propiedad por defecto de la Clase1 en la variable
Clase2... An as, esto de que las propiedades Default deban tener
parmetros, puede ser algo engorroso y llevar a errores, sobre todo
para los casos en los que debe devolver un valor; por eso, mi
recomendacin es que las uses para propiedades que actuan al estilo de
un array, es decir que reciben el parmetro para devolver un valor
determinado

Veamos unos ejemplos de cmo declarar las Propiedades:
'
Public Property Nombre() As String
' Parte Get (la que devuelve el valor)
Get
' Devolvemos el valor de la variable
que guarda el Nombre
Return m_Nombre
End Get
' Parte Set (la que asigna el valor de la
propiedad)
Set
' Asignamos el nuevo valor a la
variable que contendr el Nombre
m_Nombre = Value
End Set
End Property

Como puedes ver, dentro del procedimiento Property, se puede crear el
cdigo de lo que se har cuando se asigne un valor a esa propiedad
(parte SET) o cuando se devuelva un valor por esa propiedad (parte
GET). En el caso de que la propiedad no tenga parmetros, el valor
asignado ser el indicado por Value.
Fjate tambin en que ahora para devolver el valor en la parte Get, se
puede usar Return <expresin a devolver>, aunque si lo prefieres,
puedes devolver el valor con el formato usado por las versiones
anteriores de Visual Basic, es decir: NombrePropiedad = <expresin
a devolver>

En el caso de que una propiedad sea de slo lectura, no contendr la
parte SET, pero adems habr que indicarlo con ReadOnly, lo mismo
ocurre con las propiedades de slo escritura, (las que no tienen la parte
GET), pero en este caso habr que usar WriteOnly:
'
Public Default ReadOnly Property
Item(ByVal unSaludo As String) As String
Get
Return unSaludo & " " & Nombre1
End Get
End Property

Si adems quieres que una clase derivada pueda implementar su propia
versin de un mtodo o propiedad, habr que declarar ese
procedimiento con: Overridable en la clase base y con Overrides en
la clase derivada:
' En la Clase base:
Overridable Public Function
ShowNombre() As String
Return Nombre
End Function

' En la clase derivada:
Overrides Public Function ShowNombre()
As String
' La variable Nombre se declar en
Clase1
Return "El Nombre almacenado en
Clase1: " & Nombre
End Function

Si necesitamos acceder al mtodo original de la clase base, habr que
indicarlo de esta forma: MyBase.Mtodo
MyBase representa al objeto del que se ha derivado la clase.
En un intento de conseguir que tu "linda" cabecita empiece a echar
humo, vamos a ver otra de las nuevas "particularidades" que nos trae el
vb.NET con respecto a la "verdadera" (por fin!) Programacin
Orientada a Objetos (OOP segn la abreviatura inglesa), en este caso
es a la sobrecarga de procedimientos. Esto del Polimorfismo, hasta
ahora, slo nos permita poder usar mtodos con el mismo nombre en
diferentes clases y mediante la herencia implementada de otras clases
con Implements), el compilador saba a que objeto llamar... pero slo
se poda hacer con el mismo nombre del mtodo o propiedad en
diferentes clases. Con la nueva versin de VB, tambin podemos
hacerlo en la misma clase.
Cmo? usando el modificador Overloads.
Para que sirve Overloads?, imaginate que un mismo procedimiento
permite diferentes tipos de datos como parmetro y segn ese tipo de
dato devolver el adecuado... o bien que reciba parmetros opcionales y
segn los parmetros recibidos acte de una forma u otra... En todos
estos casos, puedes definir diferentes procedimientos (con el mismo
nombre), pero que cada uno acte de forma adecuada segn los
parmetros recibidos. Lo que no se puede hacer es declarar varios
procedimientos en los que slo se diferencia el tipo de dato devuelto.
Vaya lo! verdad?
Vamos a aclararlo con algn que otro ejemplo:
'
' Recibe parmetros Integer y devuelve
un Integer
Public Overloads Function Suma(ByVal a
As Integer, ByVal b As Integer) As Integer
Return a + b
End Function
' Recibe parmetros Double y devuelve
un Double
Public Overloads Function Suma(ByVal a
As Double, ByVal b As Double) As Double
Return a + b
End Function
'
' Estos procedimientos reciben
distintos tipos de parmetros,
' pero devuelven el mismo tipo
Public Overloads Function aCadena(ByVal
a As Integer) As String
Return "Es un Integer convertido a
cadena: " & a.ToString
End Function
'
Public Overloads Function aCadena(ByVal
a As Double) As String
Return "Es un Double convertido a
cadena: " & a.ToString
End Function
'

Te qued ms claro ahora?

Nota: Los parmetros a procedimientos ahora son ByVal por
defecto, en las versiones anteriores eran ByRef.



Cmo... usar otros modificadores de
Mtodos (Shared, Overridable, etc.)
Aqu vermos otros modificadores para la definicin de mtodos.

Adems de los modificadores de "alcance" que vimos anteriormente, hay otros
modificadores aplicables a los mtodos que indicarn la forma de comportarse
(o de cmo se dejarn manipular...)

Vamos a ver cada uno de ellos y lo que dice la ayuda del .NET SDK:
Shared:
Este modificador indica que el mtodo es un mtodo compartido. Los
mtodos compartidos no actuan en una instancia determinada de un
tipo. Aparte de los declarados en mdulos estndard, un mtodo
declarado sin el modificador Shared se llama un mtodo de instancia. Un
mtodo de instancia, opera sobre una instancia de un tipo. Un mtodo
compartido no puede ser Overridable (o sobre-escrito), y por tanto no
debe especificar ninguno de los modificadores: Overridable,
NotOverridable, MustOverridable o Overrides.
Aplicando esto a las actuales versiones de Visual Basic, es como si
declarasemos un mtodo en un fichero BAS incluido en un componente,
(e incluso en un programa normal), cada vez que se crea un objeto de
una clase de ese componente, creamos una nueva instancia de dicha
clase, sin embargo los mtodos declarados en los mdulos BAS de ese
componente seran "compartidos" por todas las instancias creadas. En
C++ es lo que se llama un mtodo esttico (static)
Overridable:
Este modificador indica que el mtodo puede ser "anulable" o
"redefinible" (no he encontrado una traduccin mejor). Un mtodo
redefinible no debe ser declarado como Shared ni NotOverridable y no
debera combinarse con MustOverride o Overrides, (ya que ambos
implican Overridable). Mtodos en clases definitivas no deberan
declararse como Overridable y las funciones declaradas con este
modificador no deberan ser Privadas (Private).
Este modificador se aplica a los mtodos que queremos usar de forma
"polimfica", es decir que podemos tener un mtodo en una clase el cual
puede ser "redefinido" u ocultado por otro con el mismo nombre en una
clase derivada. Esto se usa para que, dependiendo de la clase en la que
se defina, acte de forma adecuada sobre los datos manejados por esa
clase.
NotOverridable:
Este modificador indica que el mtodo es final. Un mtodo que especifica
NotOverridable tambin debe especificar Overrides y no debera
especificar Shared, Overridable o MustOverride. Mtodos finales no
deben ser Private ya que es redundante.
Si se especifica este modificador, las clases derivadas no podrn crear
mtodos con este mismo nombre que "anulen" o redefinan al mtodo de
la clase heredada.
MustOverride:
Este modificador indica que las clases derivadas debern crear
explcitamente un mtodo con el modificador Overrides que redefina la
funcionalidad del mtodo. Segn la ayuda del SDK, este modificador
indica que un mtodo es abstracto y los mtodos abstractos no deben
incluir cdigo, no deben redefinir otro mtodo y deben aparecer slo en
clases (o tipos) abstractos. Un mtodo abstracto no debe especificar
Shared, Overridable, NotOverridable ni Overrides. Los mtodos
abstractos no pueden ser Private.
Es decir, MustOverride se usar slo como definiciones de mtodos a
redefinir por las clases derivadas y slo aparecer en las clases
abstractas, por tanto lo nico que se aportar sern los parmetros que
tiene, el tipo de datos a devovler y la "visibilidad" de dicho mtodo... no
se si en VB se podrn crear clases abstractas... an no he llegado a
eso... pero todo se andar...
Overrides:
El modificador Overrides indica que este mtodo redefine un mtodo
incluido en la clase base (de la que se deriva la clase) y debe tener la
misma "firma", es decir que tenga los mismos parmetros y el tipo
devuelto sea el mismo, (en el caso de que fuese una funcin). Un
mtodo con este modificador no debe especificar Shadows, Shared,
Overridable, o MustOverride. Si no existiera un mtodo al que poder
redefinir, se producira un error.
Este modificador se usa cuando queremos crear un mtodo que redefina
a otro existente en una de las clases de la que se derive la clase que lo
contiene, por ejemplo para manipular los datos de forma ms adecuada
a esta clase.
Overloads:
Este modificador indica que un mtodo "sobrecarga" a otro existente en
la misma clase. Cada uno de los mtodos "sobrecargados" deben tener
una firma diferente, es decir el nmero o los tipos de parmetros deben
ser diferentes.
Nota: El nico modificador que debe especificar un mtodo declarado
en un mdulo es: Overloads.
En la seccin que trata los mtodos hay varios ejemplos de Overloads,
Overridable y Overrides.


Ejemplos: ms vale un poco de cdigo que
10.000 palabras.

Pues eso... aqu tienes unos links a pginas con cdigo de ejemplo de las
diferentes cosillas que he ido probando en estos das. Espero que los
comentarios incluidos sean suficientes... aunque an no descarto de incluir
algo de ms explicacin.
Prueba de sobrecarga de procedimientos
Prueba de declaracin de variables y visibilidad
Prueba de acceso a listas: de un ListBox, Array y Collection (compatible
con versiones anteriores de Visual Basic)
Prueba de acceso a listas: de un ListBox, Array, ArrayList (colecciones
mejoradas) y StringCollection
Prueba de convertir una clase de versiones anteriores a VB.NET
(cNum2Text)

Cmo usar el MessageBox: (17~22/Mar/2001)
Talvez parezca una simpleza, pero... como en VB.NET se usa de forma distinta
que en el Visual Basic de ahora... pues aqu tienes algunos consejos o formas
de cmo usar esta funcin que sirve para mostrar mensajes en la pantalla.
Para mostrar un mensaje, se usa de esta forma: MessageBox.Show("Texto
a mostrar", "Ttulo de la ventana", Botones e icono)
En Botones e icono, se pueden usar cualquiera de los valores devueltos por el
objeto MessageBox, veamos algunos de ellos:
AbortRetryIgnore Muestra los botones de Anular, Reintentar, Ignorar
DefaultButton1 (2
3)

Hace que el botn predeterminado sea el 1 (o el
2 o el 3)
DefaultDesktopOnly

El mensaje se muestra en el escritorio activo,
siempre que haya un usuario activo.
IconAsterisk

Muestra el icono de asterisco, (aunque por ahora
muestra el de Informacin).
IconError

Muestra el icono de error.
IconExclamation

Muestra el icono de exclamacin.
IconHand

Muestra el icono de una mano, (aunque por ahora
muestra el de error).
IconInformation

Muestra el icono de informacin.
IconQuestion

Muestra el icono de interrogacin.
IconStop

Muestra el icono de stop, (aunque es el mismo que
el de error).
OK

Muestra el botn de Aceptar (este es el botn por
defecto, si no se indica ningn otro)
OKCancel Muestra los botones de Aceptar y Cancelar
RetryCancel Muestra los botones de Reintentar y Cancelar
RightAlign Justificar el texto por la derecha
RTLReading

Para los idiomas que se muestran de derecha a
izquierda
ServiceNotification

El mensaje se muestra en el escritorio activo,
aunque no haya un usuario activo.
YesNo Mostrar los botones Si y No
YesNoCancel Mostrar los botones Si, No y Cancelar
Para los valores devuelto por MessageBox, se usan las constantes de
DialogResult, que son las siguientes:
Abort
Cancel
Ignore
No
None
OK
Retry
Yes
Veamos ahora algunos ejemplos de uso de MessageBox:
La forma ms simple: (como no se indica que tipo de botn mostrar, se
muestra el botn OK (Aceptar))
MessageBox.Show("Mensaje en la pantalla")
Si queremos que se muestre el icono de interrogacin: (idem que antes, se
muestra OK)
MessageBox.Show("Mensaje en la pantalla con el icono de interrogacin",
"Ttulo", MessageBox.IconQuestion)
Si queremos mostrar los botones OK y Cancel (Aceptar y Cancelar):
(ret guardar el valor del botn pulsado)
ret = MessageBox.Show("Mensaje en la pantalla con dos botones: Aceptar y
Cancelar", "Ttulo", MessageBox.OKCancel)
Si queremos mostrar los botones Yes y No (Si / No) adems del icono de
informacin:
(ret guardar el valor del botn pulsado)
ret = MessageBox.Show("Mensaje en la pantalla...", "Ttulo",
MessageBox.YesNo BitOr MessageBox.IconInformation)
(en lugar de BitOr se puede usar el signo + (ms), pero no Or, ya que el
significado es diferente)
Si queremos indicar qu ventana es la propietaria (owner) del MessageBox,
indicar como primer parmetro el formulario propietario:
(ret guardar el valor del botn pulsado)
ret = MessageBox.Show(Form1, "Mensaje en la pantalla...", "Ttulo",
MessageBox.YesNo BitOr MessageBox.IconInformation) .
Pulsa este link para ver un proyecto con un ejemplo de cmo usar MessageBox
adems de copiar en el clipboard el cdigo necesario para generar un
messagebox.

Cmo usar un procedimiento para manejar los eventos
varios controles:
La nueva versin de Visual Basic, (al menos en la Beta1), permite, mediante el
modificador Handles, usar un slo procedimiento para interceptar los eventos
producidos en varios controles, siempre y cuando los parmetros recibidos
sean del mismo tipo.
Osea que para crear un procedimiento para un evento: Nombre del
procedimiento Handles Nombre del evento.
Private Sub button1_Click(ByVal sender As Object, ByVal e As
EventArgs) Handles button1.Click
Por supuesto, el nombre del procedimiento puede ser cualquiera, no hay
porqu seguir las reglas de: NombreDelControl_NombreDelEvento, adems de
poder usar un mismo procedimiento para manejar los eventos de varios
botones:
Private Sub botonesClick(ByVal sender As Object, ByVal e As
EventArgs) Handles button1.Click, button2.Click
Para saber que botn se ha pulsado, por ahora slo puedes comprobar alguna
de las propiedades del botn, por ejemplo el texto que tiene (antes llamado
Caption), aunque segn he oido por ah, en la versin definitiva estar
implementada la propiedad Name o alguna que nos permita distinguirlo del
resto de los controles...

Private Sub BotonesPulsados(ByVal sender As Object, ByVal e
As EventArgs) Handles button1.Click, button2.Click
If CType(sender, Button).Text = "Leer..." Then
textBox1().Text = "Has pulsado en el botn 1"
ElseIf CType(sender, Button).Text = "Guardar..." Then
textBox1().Text = "Has pulsado en el botn 2"
End If
End Sub


Ir al ndice de vb.net