índice de vb.net Cómo... en VB .NET

Código de ejemplo de recordatorio para mentes olvidadizas (como la mía)

Iniciado el 27/Oct/2000
Actualizado: 28/Dic/2003 (11/Abr/2001)

NOTA del 13/Jun/2002:
A partir de esta fecha, todo lo relacionado con .NET se accederá desde una nueva página, así que...
si no quieres perderte nada sobre este nuevo "sistema" de desarrollo, sigue este link.

Los links a partir del 1/Abr/2001:

 

Los links a partir del 22/Mar/2001 (VS.NET Beta1):

 

Los links del 25/Oct/2000 (.NET Framework preview):

 

Conceptos básicos: Tipos de ficheros o módulos que se pueden usar en VB.NET
Aunque los ficheros de código usados para compilar programas para Visual Basic .NET pueden tener cualquier extensión, es recomendable usar la "nueva" extensión .vb; a nuestro criterio queda el usar otras extensiones.
Realmente lo quen interesa es el contenido del fichero. Antes cada tipo de fichero tenía un significado para el entorno integrado del Visual Basic, pero ahora ya no lo tiene... aunque el diseñador de formularios da por hecho que los listados de Visual Basic sean los que tengan la extensión .vb y los de c# los que tengan la extensión .cs.

Como te decía, lo realmente importante es el contenido del fichero en cuestión, dentro de ese fichero pueden existir varias clases, diferentes Namespaces y formularios, etc. Vamos a ver que podemos usar, cómo y cuando es recomendable usarlo:

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, serán Private. Por tanto, es recomendable usar siempre el modificador.
Los miembros declarados como Private, sólo serán accesibles en el Namespace en el que se declararon.

Cómo... 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 versión definitiva, tendrás 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 parámetro /out, por ejemplo: /out:Nombre.exe


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

/target:exe Crea un .exe del tipo consola.
/target:library Crea una librería de código (DLL).
/target:module Crea un módulo.
/target:winexe Crea un ejecutable de Windows. Este es el valor por defecto, osea: cuando no se especifica la opcion target.

Cómo... 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 cómo manejar y acceder a los elementos, añadirlos, borrarlos, etc. Esto también es aplicable al ComboBox.

Borrar el contenido de un ListBox: ListBox1.Items.Clear

Añadir 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 numérico:
ListBox1.GetItemText(ListBox1.Items(índice))

También podemos tomar el texto de un elemento mediante un índice numérico usando algo como:
s = ListBox1.Items(índice).ToString()


Tomar el elemento 'Clickeado' y asignarlo a un TextBox:
Esto será válido 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 cuestión es: SelectedIndexChanged

Para saber el índice del item seleccionado: i = .SelectedIndex
También para indicar el índice seleccionado: .SelectedIndex = 0

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


Cómo... Manejar un array

Todos los arrays en VB.NET empiezan con el índice cero. Al declarar un array, el número usado, indicará el número de elementos, éstos irán desde 0 hasta el número 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 serán de 0 a N-1): Dim unArray(7) As String

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

Saber el número 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 comprobación es conveniente, ya que si el Array aún 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 más 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




Cómo... Convertir un número en un carácter

Usando CChar(x) podemos convertir un número en un carácter, 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 versión definitiva CChar() sólo acepta valores de tipo String.
Para convertir un número en un tipo Char, se puede usar Chr() o ChrW() 

 

Cómo... usar colecciones mejoradas: ArrayList

Las colecciones ArrayList son como las colecciones de Visual Basic, pero bastante mejoradas, veamos algunas de las propiedades y métodos, ya que considero que este tipo de lista (o colección) puede ser de gran utilidad.
Nota: Para poder usarla hay que indicar: Imports System.Collections.

Propiedades:
Capacity: Asigna o devuelve el número máximo de elementos que contendrá el ArrayList.
Este valor siempre será igual o mayor que el devuelto por Count. Si al añadir un nuevo elemento, Count fuese mayor que Capacity, la capacidad del array interno se duplicaría para que se pudiesen añadir nuevos elementos. Si se asigna directamente un valor, el array interno se adaptaría a ese valor.
Count: Devuelve el número de elementos actuales.
Item: Asigna o devuelve el elemento indicado.

Métodos:
Add: Añade un nuevo elemento al final del array (o colección).
BinarySearch: Realiza una búsqueda 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 sólo se pueden modificar elementos, no añadirlos 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 reflejarán 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 colección en el índice indicado.
LastIndexOf: Devuelve el índice de la última ocurrencia del elemento indicado.
ReadOnly: Devuelve un list wrapper con acceso de sólo 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 número de veces.
Reverse: Invierte el orden de los elementos de la lista o del rango indicado.
SetRange: Copia los elementos de una colección 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 representación del objeto como una cadena. Dependiendo de la implementación de este método, puede devolver el nombre completo de la clase o bien la representación del valor.
TrimToSize: Asigna la capacidad de la lista al número de elementos que tiene actualmente, útil cuando sabemos que no vamos a modificar el número de elementos. Para borrar totalmente los elementos de un ArrayList, llamar antes al método Clear y después a TrimToSize.

Cómo... saber cuando usar Protected, Private, etc.

Estos modificadores de declaraciones de clases, métodos, propiedades y variables, se usarán cuando queramos modificar el "alcance" de visibilidad de dichos miembros.

Private:
Un miembro declarado como Privado, sólo 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 declaración; por ejemplo, si se compilan varios ficheros con distintos Namespaces en un mismo programa (ejecutable o componente).

Protected Friend:
Idem que Friend, además de ser visible en las clases derivadas.

Public:
Visible por todo el mundo.


Osea, que si queremos crear miembros de la clase que sólo 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 módulo en el que está declarado pueda acceder, entonces usaremos Protected.
Si lo que queremos es que determinados miembros sean visibles sólo en el Namespace en el que se ha creado la clase o en el mismo programa en el que está la declaración, habrá que declararlos como Friend.
Y si además de que sea visible en el Namespace o programa, queremos que también 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, módulo 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 más restrictivo que la clase heredada. Por ejemplo, si Clase1 se declaró como Friend, la siguiente declaración produciría un error: Public Class Clase2 : Inherits Clase1, ya que los miembros de Clase1 no pueden "promoverse" a públicos.

Cómo... declarar variables y la visibilidad de las mismas.
Aquí veremos cómo se declaran variables (y objetos) en la nueva versión de Visual Basic, también veremos cómo ha cambiado el "alcance" o visibilidad de las variables.

Aunque había leido por ahí que ya no se pueden declarar variables Públicas en clases para que se conviertan automáticamente 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 pública 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. Aún así, esta no es la forma "deseable" de declarar una propiedad en una clase... ni en la nueva versión 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 código:
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 código.


A diferencia de las versiones anteriores de Visual Basic, en esta nueva versión no se pueden declarar variables del tipo STATIC, es decir, variables que se declaraban dentro de un procedimiento y que mantenían 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 función: Dim S As String = tClase1.Nombre()
Los objetos también se pueden declarar para que sean iniciadas en la propia declaración: Dim tClase1 As New Clase1
A diferencia de las versiones anteriores, esto no significa una "sobrecarga" de código, es decir: en las versiones anteriores de Visual Basic, si una clase se declaraba con New, el compilador tenía 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 código extra que insertaba de forma automática 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 aún 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 métodos... ver lo que dice la sección anterior.

Cómo... declarar Propiedades y Métodos en las clases.

Los métodos de una clase se declaran de la misma forma que en versiones anteriores de Visual Basic, ya sabes que un método es un procedimiento Function o Sub, según queramos que devuelva o no un valor.
Como sabrás, 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 versión de Visual Basic, las propiedades se declaran de forma diferente, ya que no existen procedimientos separados para cada tipo de acción a realizar por una propiedad.
Además 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 parámetros, 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 asignación: Clase2 = Clase1, se crearía una referencia de la Clase1 en la Clase2, no se asignaría el valor de la propiedad por defecto de la Clase1 en la variable Clase2... Aún así, esto de que las propiedades Default deban tener parámetros, puede ser algo engorroso y llevar a errores, sobre todo para los casos en los que debe devolver un valor; por eso, mi recomendación es que las uses para propiedades que actuan al estilo de un array, es decir que reciben el parámetro para devolver un valor determinado

Veamos unos ejemplos de cómo 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 código 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 parámetros, el valor asignado será el indicado por Value.
Fíjate también en que ahora para devolver el valor en la parte Get, se puede usar Return <expresión a devolver>, aunque si lo prefieres, puedes devolver el valor con el formato usado por las versiones anteriores de Visual Basic, es decir: NombrePropiedad = <expresión a devolver>

En el caso de que una propiedad sea de sólo lectura, no contendrá la parte SET, pero además habrá que indicarlo con ReadOnly, lo mismo ocurre con las propiedades de sólo 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 además quieres que una clase derivada pueda implementar su propia versión de un método 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 método original de la clase base, habrá que indicarlo de esta forma: MyBase.Método
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!) Programación Orientada a Objetos (OOP según la abreviatura inglesa), en este caso es a la sobrecarga de procedimientos. Esto del Polimorfismo, hasta ahora, sólo nos permitía poder usar métodos con el mismo nombre en diferentes clases y mediante la herencia implementada de otras clases con Implements), el compilador sabía a que objeto llamar... pero sólo se podía hacer con el mismo nombre del método o propiedad en diferentes clases. Con la nueva versión de VB, también podemos hacerlo en la misma clase.
¿Cómo? usando el modificador Overloads.
¿Para que sirve Overloads?, imaginate que un mismo procedimiento permite diferentes tipos de datos como parámetro y según ese tipo de dato devolver el adecuado... o bien que reciba parámetros opcionales y según los parámetros recibidos actúe de una forma u otra... En todos estos casos, puedes definir diferentes procedimientos (con el mismo nombre), pero que cada uno actúe de forma adecuada según los parámetros recibidos. Lo que no se puede hacer es declarar varios procedimientos en los que sólo se diferencia el tipo de dato devuelto.
¡Vaya lío! ¿verdad?
Vamos a aclararlo con algún que otro ejemplo:

'
        ' Recibe parámetros 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 parámetros 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 parámetros,
        ' 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ó más claro ahora?


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


 

Cómo... usar otros modificadores de Métodos (Shared, Overridable, etc.)
Aquí vermos otros modificadores para la definición de métodos.

Además de los modificadores de "alcance" que vimos anteriormente, hay otros modificadores aplicables a los métodos que indicarán la forma de comportarse (o de cómo se dejarán manipular...)

Vamos a ver cada uno de ellos y lo que dice la ayuda del .NET SDK:

Nota: El único modificador que debe especificar un método declarado en un módulo es: Overloads.

En la sección que trata los métodos hay varios ejemplos de Overloads, Overridable y Overrides.


Ejemplos: más vale un poco de código que 10.000 palabras.

Pues eso... aquí tienes unos links a páginas con código de ejemplo de las diferentes cosillas que he ido probando en estos días. Espero que los comentarios incluidos sean suficientes... aunque aún no descarto de incluir algo de más explicación.

Cómo 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 cómo usar esta función que sirve para mostrar mensajes en la pantalla.

Para mostrar un mensaje, se usa de esta forma: MessageBox.Show("Texto a mostrar", "Título 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 botón 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 Información).
IconError Muestra el icono de error.
IconExclamation Muestra el icono de exclamación.
IconHand Muestra el icono de una mano, (aunque por ahora muestra el de error).
IconInformation Muestra el icono de información.
IconQuestion Muestra el icono de interrogación.
IconStop Muestra el icono de stop, (aunque es el mismo que el de error).
OK   Muestra el botón de Aceptar (este es el botón por defecto, si no se indica ningún 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 más simple: (como no se indica que tipo de botón mostrar, se muestra el botón OK (Aceptar))
MessageBox.Show("Mensaje en la pantalla")

Si queremos que se muestre el icono de interrogación: (idem que antes, se muestra OK)
MessageBox.Show("Mensaje en la pantalla con el icono de interrogación", "Título", MessageBox.IconQuestion)

Si queremos mostrar los botones OK y Cancel (Aceptar y Cancelar):
(ret guardará el valor del botón pulsado)
ret = MessageBox.Show("Mensaje en la pantalla con dos botones: Aceptar y Cancelar", "Título", MessageBox.OKCancel)

Si queremos mostrar los botones Yes y No (Si / No) además del icono de información:
(ret guardará el valor del botón pulsado)
ret = MessageBox.Show("Mensaje en la pantalla...", "Título", MessageBox.YesNo BitOr MessageBox.IconInformation)
(en lugar de BitOr se puede usar el signo + (más), pero no Or, ya que el significado es diferente)

Si queremos indicar qué ventana es la propietaria (owner) del MessageBox, indicar como primer parámetro el formulario propietario:
(ret guardará el valor del botón pulsado)
ret = MessageBox.Show(Form1, "Mensaje en la pantalla...", "Título", MessageBox.YesNo BitOr MessageBox.IconInformation) .

Pulsa este link para ver un proyecto con un ejemplo de cómo usar MessageBox además de copiar en el clipboard el código necesario para generar un messagebox.

Cómo usar un procedimiento para manejar los eventos varios controles:

La nueva versión de Visual Basic, (al menos en la Beta1), permite, mediante el modificador Handles, usar un sólo procedimiento para interceptar los eventos producidos en varios controles, siempre y cuando los parámetros 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, además 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 botón se ha pulsado, por ahora sólo puedes comprobar alguna de las propiedades del botón, por ejemplo el texto que tiene (antes llamado Caption), aunque según he oido por ahí, en la versión 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 botón 1"
	ElseIf CType(sender, Button).Text = "Guardar..." Then
		textBox1().Text = "Has pulsado en el botón 2"
	End If
End Sub

Ir al índice de vb.net

la Luna del Guille o... el Guille que está en la Luna... tanto monta...