Ejemplo Visual Basic – Menú contextual


En este artículo se pretende mostrar un ejemplo de una característica presente en la mayoría de aplicaciones: el menú contextual. Principalmente esta dirigido a todo aquel que quiera iniciarse en el desarrollo de programas con el lenguaje Visual Basic. Para su realización se ha usado el entorno Microsoft Visual Basic 2010 Express, que puede obtenerse gratuitamente en el siguiente enlace.
Este ejemplo consiste en un formulario que posee un menú emergente. Este se muestra cuando se pulsa el botón derecho del ratón. El menú posee las opciones de mostrar o ocultar una imagen, la opción de cambiar el color de fondo del formulario, y la opción de salir de la aplicación.
En primer lugar creamos un nuevo proyecto escogiendo la plantilla Aplicación de Windows Forms con el nombre MenuContextual.


Por defecto, se asigna el nombre de archivo Form1.vb, así pues le asignaremos un nombre más descriptivo cómo MenuContext1.vb. Hay dos formas de hacerlo:

  • editando directamente el nombre en el Explorador de soluciones seleccionando el archivo y en el menú contextual la opción cambiar nombre
  • guardando el archivo en el menú Archivo y el submenú Guardar archivo como..

A continuación definimos algunas propiedades del formulario. En la propiedad Name le vamos a asignar el nombre FrmMenuContext, y como título a mostrar indicaremos en la propiedad Text la frase “Ejemplo Menú Contextual “. También vamos a indicar que no se pueda maximizar la ventana seleccionando el boleano False en la propiedad MaximizeBox, y que esta se muestre en el centro de la pantalla seleccionando la opción CenterScreen de la propiedad StartPosition. Además vamos a indicar que no se pueda modificar el tamaño de la aplicación con la propiedad FormBorderStyle y la opción FixedSingle.
En resumen, debemos modificar las siguientes propiedades del formulario:

Name = FrmMenuContext
Text = Ejemplo Menú Contextual
StartPosition = CenterScreen
MaximizeBox = False
FormBorderStyle = FixedSingle

El siguiente paso es añadir el menú contextual, para ello en el cuadro de herramientas seleccionamos el control ContextMenuStrip ubicado en el apartado Menús y barras de herramientas, y en la propiedad Name le asignamos el nombre FormContextMenuStrip.

Ahora debemos indicar que este menú emergente será el del formulario. Para ello en las propiedades del formulario, editamos la propiedad ContextMenuStrip y escogemos el FormContextMenuStrip que previamente hemos creado.

Nota: un menú contextual (componente ContextMenuStrip) debe estar asociado a un control que puede ser un formulario, botón, caja de texto… y se asocia con la propiedad ContextMenuStrip del control. El menú solo se muestra al situar el ratón sobre el control y pulsar el botón derecho.
A continuación vamos a crear las opciones del menú emergente, para ello seleccionamos el componente y aparecerá automáticamente un menú editable:


Creamos dos opciones Mostrar imagen y Ocultar imagen, y les asignamos los atajos de teclado Ctrl + M y Ctrl + O en sus respectivas propiedades ShortcutKeys. Además desactivamos la opción Ocultar imagen estableciendo a falso su propiedad Enabled.
Propiedades a modificar de Mostrar imagen:
Text = Mostrar imagen
ShortcutKeys = Ctrl+M
Propiedades a modificar de Ocultar imagen:
Text = Ocultar imagen
ShortcutKeys = Ctrl+O
Enabled = False

A continuación introducimos un separador en el menú, para ello pinchamos en la caja combinada con el texto ‘Escriba aquí’, que se utiliza para crear opciones del menú, y escogemos la opción Separator.

Cómo se puede observar, los menús pueden tener una opción normal (MenuItem), una caja combinada (ComboBox), un separador (Separator) o una caja de texto (TextBox).
Siguiendo con el menú de ejemplo, añadimos un nuevo item con el texto Color y le añadimos un submenú con una caja combinada. A esta caja le asignamos el nombre ColoresToolStripComboBox, y le indicamos que sólo muestre una lista despegable sin que se pueda editar, para ello establecemos la opción DropDownList de la propiedad DropDownStyle. También escogemos la opción Standard de la propiedad FlatStyle que determina el aspecto de la caja. Finalmente en la propiedad Items añadimos los elementos de la caja que serán los posibles colores del formulario.
Propiedades a modificar de la caja combinada:
Name = ColoresToolStripComboBox
DropDownStyle = DropDownList
FlatStyle = Standard
Items =
Amarillo
Azul
Rojo
Verde

Finalmente añadimos otro separador al menú y una última opción con el nombre Salir y el atajo de teclado Ctrl + S.
Propiedades a modificar de Salir:
Text = Salir
ShortcutKeys = Ctrl+S


Una vez completado el menú, vamos a añadir la imagen a mostrar o ocultar del formulario. Para ello en el cuadro de herramientas escogemos el componente PictureBox y lo arrastramos hasta el formulario.


Como nombre le asignamos PicBxImagen y indicamos que por defecto no se muestre escogiendo el valor False en la propiedad Visible. También indicamos que no se pueda modificar con la propiedad Locked y que el tamaño del control se adapte al de la imagen.
Propiedades a modificar del PictureBox:
Name = PicBxImagen
Visible = False
SizeMode = AutoSize
Locked = True
En la propiedad Image, escogeremos el archivo de imagen que mostrará el PictureBox. Se abrirá un cuadro de dialogo donde deberemos seleccionar la opción Recurso local y a continuación pulsar el botón Importar, donde escogeremos la imagen.

Finalmente añadiremos una etiqueta (componente Label) para informar del funcionamiento de la aplicación. Para ello modificaremos las siguientes propiedades del Label:
Name = LblInfo
Text = Pulsa el botón derecho del ratón para ver el menú contextual
Una vez finalizado el diseño del ejemplo, vamos a codificar los eventos del menú.
En primer lugar en el evento Click de la opción Mostrar imagen vamos a indicar que se muestre la imagen activando la propiedad Visible del PictureBox. También vamos a habilitar la opción de ocultar la imagen y a la vez deshabilitar la opción de mostrar la imagen, puesto que esta ya se estará mostrando.

Código del evento Click de la opción Mostrar imagen:

Private Sub MostrarImagenToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MostrarImagenToolStripMenuItem.Click

Me.PicBxImagen.Visible = True
Me.OcultarImagenToolStripMenuItem.Enabled = True
Me.MostrarImagenToolStripMenuItem.Enabled = False
End Sub

En el evento Click de la opción Ocultar imagen vamos a indicar que no se muestre la imagen desactivando la propiedad Visible del PictureBox. También vamos a deshabilitar la opción de ocultar la imagen y habilitar la opción de mostrar la imagen.
Código del evento Click de la opción Ocultar imagen:

Private Sub OcultarImagenToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles OcultarImagenToolStripMenuItem.Click
Me.PicBxImagen.Visible = False
Me.OcultarImagenToolStripMenuItem.Enabled = False
Me.MostrarImagenToolStripMenuItem.Enabled = True
End Sub

En el evento Click de la opción Salir simplemente indicaremos que se cierre la aplicación.

Código del evento Click de la opción Salir:

Private Sub SalirToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SalirToolStripMenuItem.Click
Me.Close()
End Sub
Tan solo nos quedará codificar el evento SelectedIndexChanged de la caja combinada ColoresToolStripComboBox. Según el elemento que se seleccione en la caja, se asignará un nuevo color de fondo para el formulario.
Código del evento SelectedIndexChanged de la caja combinada de la opción Colores:
Private Sub ColoresToolStripComboBox_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ColoresToolStripComboBox.SelectedIndexChanged
Select Case ColoresToolStripComboBox.SelectedItem
Case "Amarillo"
Me.BackColor = Color.Yellow
Case "Azul"
Me.BackColor = Color.Blue
Case "Rojo"
Me.BackColor = Color.Red
Case "Verde"
Me.BackColor = Color.Green
End Select
Me.ContextMenuStrip.Close()
End Sub
End Class

Tan solo quedará ejecutar el ejemplo para comprobar que funciona correctamente.

Visual Basic – Barra de herramientas y menú estándar


Hoy quiero destacar una característica del entorno Microsoft Visual Basic que nos puede ahorrar tiempo. Se trata de la barra de herramientas y el menú estándar. Esta opción, esta presente en las versiones 2005, 2008 y 2010 de Visual Studio. Para realizar este artículo se ha utilizado Microsoft Visual Basic 2010 Express.
En primer lugar vamos a ver cómo crear en nuestro proyecto un menú estándar. Para ello creamos un nuevo proyecto con la plantilla Aplicación de Windows Forms. Luego insertamos en el formulario el componente MenuStrip ubicado en el apartado Menús y barras de herramientas del Cuadro de herramientas.

Seleccionamos el componente y pulsamos el botón derecho del ratón, en el menú que aparece seleccionamos la opción Insertar elementos estándar.


Podemos observar cómo se ha creado un menú con los elementos típicos Archivo, Editar, Herramientas y Ayuda, y sus correspondientes submenús. De esta forma nos ahorramos el tiempo de crearlos y simplemente tenemos que añadir, editar o eliminar las opciones que no necesitamos. Lógicamente sólo se crea la estructura, la codificación la deberemos hacer nosotros.


El mismo procedimiento sirve para crear una barra de herramientas estándar. Para ello insertamos en el formulario el componente ToolStrip también ubicado en el apartado Menús y barras de herramientas del Cuadro de herramientas.


Seleccionamos el componente y pulsamos el botón derecho del ratón, en el menú que aparece seleccionamos la opción Insertar elementos estándar.


De este modo ya tendremos una barra de herramienta con los elementos típicos Nuevo, Abrir, Guardar, Imprimir, Cortar, Copiar, Pegar y Ayuda. Podemos personalizar esta barra editando, eliminando o añadiendo nuevos elementos.

VB.Net y los métodos de extensión


Los métodos de extensión es una de la características nuevas en VB.Net y C#. Estos métodos permiten agregar métodos a las clases existentes de .Net Framework o nuestras propias clases.

Para este ejemplo voy usar la clásica función convertir números a letras.

primero se crea un modulo en VB.NET con Visual Studio 2008/2010. El nombre de mi modulo será Extensiones, ahí guardare todas los métodos de extensión, aquí el código:


Imports System.Runtime.CompilerServices
Module Extensiones
End Module

Es necesario importar System.Runtime.CompilerServices, con ella se usara el atributo <Extension()> para establecer que es un método de extensión. Siguiente paso es crear el método NUM2TEXT, como se muestra:


Imports System.Runtime.CompilerServices
Module Extensiones
         <Extension()> _    
     Public Function Num2Text(ByVal value As String) As String    
        Dim str As String = String.Empty
        Select Case Convert.ToDouble(value)
            Case 0 : str = "CERO"
            Case 1 : str = "UN"
            Case 2 : str = "DOS"
            Case 3 : str = "TRES"
            Case 4 : str = "CUATRO"
            Case 5 : str = "CINCO"
            Case 6 : str = "SEIS"
            Case 7 : str = "SIETE"
            Case 8 : str = "OCHO"
            Case 9 : str = "NUEVE"
            Case 10 : str = "DIEZ"
            Case 11 : str = "ONCE"
            Case 12 : str = "DOCE"
            Case 13 : str = "TRECE"
            Case 14 : str = "CATORCE"
            Case 15 : str = "QUINCE"
            Case Is < 20 : str = "DIECI" & Num2Text(value - 10)
            Case 20 : str = "VEINTE"
            Case Is < 30 : str = "VEINTI" & Num2Text(value - 20)
            Case 30 : str = "TREINTA"
            Case 40 : str = "CUARENTA"
            Case 50 : str = "CINCUENTA"
            Case 60 : str = "SESENTA"
            Case 70 : str = "SETENTA"
            Case 80 : str = "OCHENTA"
            Case 90 : str = "NOVENTA"
            Case Is < 100 : str = Num2Text(Int(value \ 10) * 10) & " Y " & Num2Text(value Mod 10)
            Case 100 : str = "CIEN"
            Case Is < 200 : str = "CIENTO " & Num2Text(value - 100)
            Case 200, 300, 400, 600, 800 : str = Num2Text(Int(value \ 100)) & "CIENTOS"
            Case 500 : str = "QUINIENTOS"
            Case 700 : str = "SETECIENTOS"
            Case 900 : str = "NOVECIENTOS"
            Case Is < 1000 : str = Num2Text(Int(value \ 100) * 100) & " " & Num2Text(value Mod 100)
            Case 1000 : str = "MIL"
            Case Is < 2000 : str = "MIL " & Num2Text(value Mod 1000)
            Case Is < 1000000 : str = Num2Text(Int(value \ 1000)) & " MIL"
                If value Mod 1000 Then str = str & " " & Num2Text(value Mod 1000)
            Case 1000000 : str = "UN MILLON"
            Case Is < 2000000 : str = "UN MILLON " & Num2Text(value Mod 1000000)
            Case Is < 1000000000000.0# : str = Num2Text(Int(value / 1000000)) & " MILLONES "
                If (value - Int(value / 1000000) * 1000000) Then str = str & " " & Num2Text(value - Int(value / 1000000) * 1000000)
            Case 1000000000000.0# : str = "UN BILLON"
            Case Is < 2000000000000.0# : str = "UN BILLON " & Num2Text(value - Int(value / 1000000000000.0#) * 1000000000000.0#)
            Case Else : str = str(Int(value / 1000000000000.0#)) & " BILLONES"
                If (value - Int(value / 1000000000000.0#) * 1000000000000.0#) Then str = str & " " & Num2Text(value - Int(value / 1000000000000.0#) * 1000000000000.0#)
        End Select
        Return str
    End Function
End Module

Para probar este método de extensión:


Dim Num1 As String = "1234567890123"
        MessageBox.Show(Num1.Num2Text)

el resultado es:

metodoextension1AlonsoMorales

El método Num2Text se agrego como método de extensión a la clase string. Aquí tengo mi clases Factura con la propiedad ImporteTotal:


Public Class clsFactura
    Property ImporteTotal As Double
End Class

En este código se puede ver como se usa:


 Dim MiFactura As New clsFactura With {.ImporteTotal = 15918}
        MessageBox.Show(MiFactura.ImporteTotal.ToString.Num2Text)

El primer parámetro especifica el tipo de datos que el método de extensión extiende, es obligatorio y no puede ser opcional.

¿Cuál es mi IP pública?


El otro día estaba desarrollando un pequeño programa para actualizar un nombre de dominio que tengo en el proveedor de DNS gratuito de No-IP y necesitaba saber mi IP pública. Buscando encontré que la página What Is My IP ofrece una página ASP que te ofrece esta información así que he creado la siguiente función:

  1. Imports System.Net
  2. Imports System.IO

Function WhatIsMyIP
  1. Public Function WhatIsMyIP() As String
  2.  
  3.         Dim WhatIsMyIPUrl As String = "http://whatismyip.com/automation/n09230945.asp&quot;
  4.         Dim req As HttpWebRequest
  5.         Dim res As HttpWebResponse
  6.         Dim Stream As IO.Stream
  7.         Dim PublicIP As String = String.Empty
  8.         Dim sr As StreamReader
  9.         Try
  10.             req = WebRequest.Create(WhatIsMyIPUrl)
  11.             res = req.GetResponse()
  12.             Stream = res.GetResponseStream()
  13.             sr = New StreamReader(Stream)
  14.             PublicIP = sr.ReadToEnd()
  15.             sr.Dispose()
  16.         Catch ex As Exception
  17.         End Try
  18.  
  19.         Return PublicIP
  20.     End Function

VB.NET en los dispositivos móviles inteligentes


Como el título lo dice si, vamos a hablar sobre vb.net y el papel que juega en los dispositivos móviles inteligente o Smartphones pero primero vamos a ver una introducción a Smartphone.

¿Qué es un Smartphone?

Un Smartphone o dispositivo móvil inteligente, es un teléfono celular con prestaciones superiores a las típicas, a menudo comparadas con las prestaciones de una PC. Sin embargo no hay un acuerdo entre los fabricantes acerca de esta definición, para algunos se trata de un teléfono que corre un sistema operativo completo e identificable, que provee una interface estándar y una plataforma para desarrollo de aplicaciones. Para otros es simplemente un teléfono móvil con funcionalidades avanzadas como: e-mail, Internet y/o un teclado integrado.

Son móviles que soportan completamente un cliente de correo electrónico con la funcionalidad completa de un organizador personal. Una característica importante de casi todos los teléfonos inteligentes es que permiten la instalación de programas para incrementar el procesamiento de datos y la conectividad. Estas aplicaciones pueden ser desarrolladas por el fabricante del dispositivo, por el operador o por un tercero.

Los sistemas operativos para móvil más usados en los teléfonos inteligentes son (datos de noviembre de 2010)

Symbian OS 36,6% (44,6% en 2009)

Android 25,5% (3,5% en 2009)

iOS 16,7% (17,1% en 2009)

BlackBerry OS 14,8% (20,7% en 2009)

Windows Mobile 2,8% (7,9% en 2009)

Bada OS

En los Smartphones que usan Windows Mobile que basa su núcleo del sistema operativo Windows CE y cuenta con un conjunto de aplicaciones básicas utilizando las API de Microsoft Windows. Está diseñado para ser similar a las versiones de escritorio de Windows estéticamente. Además, existe una gran oferta de software de terceros disponible para Windows Mobile .

Visual Basic .NET (VB.NET) es un programación orientado que se puede considerar una evolución deVisual Basic implementada sobre el framework .NET. Para aplicaciones en dispositivos móviles usamos .NET Compact Framework
Para desarrollar aplicaciones para Windows Mobile es necesario bajarse una de las SDKs disponibles: la Standard para Smartphones, o la Professional para Pocket PCs (normales o Phone Edition). Se pueden desarrollar dos tipos de aplicaciones para Windows Mobile: con código nativo o con código administrado (managed code). Código nativo es el código C++ que utiliza directamente la API de Windows Mobile, y el código administrado utiliza las clases del .NET Compact Framework con C# o VB.Net. (Windows Mobile es la única plataforma móvil importante que no soporta J2ME).

Ventajas
Facilidad de personalización. Fácil de usar e intuitivo. Sencilla integración con Exchange. La calidad de las herramientas disponibles (el propio Visual Studio, los emuladores, la SDK y su documentación…). La activa comunidad de desarrolladores existente y agrupada en torno al portal de desarrollo de Microsoft, la MSDN.

  • Fácil de migrar código desktop a dispositivos IntelliSense™
  • El editor subraya el código que no se puede ejecutar
  • La lista de Tareas muestra errores de compilación

Algunos materiales de comprensión y lectura obligada sobre Visual Studio 2010


El lanzamiento de Visual Studio 2010 está ahí, a la vuelta de la esquina.

Por esa razón, los materiales sobre Visual Studio 2010 están apareciendo como setas.

Uno de ellos es el whitepaper en inglés que ha publicado Microsoft sobre Visual Studio 2010 Profesional. De este whitepaper, me quedo especialmente con la última página, que sin llegar a ser muy extensa, nos resume en una tabla comparativa las características globales y diferencias de las diferentes versiones existentes de Visual Studio 2010, resumiendo esas diferencias en grupos de arquitectura, bases de datos, depuración y pruebas, etc.

Otro de esos materiales es un eBook que corresponde con un borrador que trata aspectos relacionados con como migrar nuestras soluciones a Visual Studio 2010. Es un borrador en formato xps de casi 64 Mb que cubre un capítulo únicamente y que es una versión preliminar de lo que será el libro final que aparecerá en verano.

El último de los materiales tiene que ver con los Training Kits, y en concreto con el Training Kit de Visual Studio 2010 y .NET Framework 4. Actualmente y aún, la última versión que existe es la de Febrero de 2010. Esta versión equivale a la versión de RC de Visual Studio 2010, pero es seguro que la versión equivalente a la RTM aparecerá en los próximos días u horas. Aún y así, este Training Kit puede ser utilizado en Visual Studio 2010 RTM sin mayores problemas. Recordemos que el Training Kit contiene presentaciones, laboratorios y demostraciones.

Ya para concluir os indico por si no lo sabéis, que el próximo 12 de Abril se lanzará oficialmente Visual Studio 2010. El lanzamiento en España se realizará en diferentes ciudades de España (Barcelona 13 de Abril, Madrid 20 de Abril, Bilbao 22 de Abril, Valencia 27 de Abril y Sevilla 29 de Abril). En la sesión de Madrid tendremos la oportunidad de contar con Jason Zander (General Manager de Visual Studio).

Referencias

Whitepaper en inglés sobre Visual Studio 2010 Profesional (formato xps – aproximadamente 2 Mb)

Borrador de migración de aplicaciones .NET a Visual Studio 2010 (formato xps – aproximadamente 64 Mb)

Training Kit de Visual Studio 2010 y .NET Framework 4 (para Visual Studio 2010 RC, pero válido para Visual Studio 2010 RTM – aproximadamente 200 Mb)

Blog de Jason Zander (General Manager de Visual Studio)

Keybindings Cards de los principales lenguajes de desarrollo de Visual Studio 2010


Microsoft ha publicado unos documentos en formato pdf que corresponden con los keybinding cards o atajos de teclado para los diferentes lenguajes de desarrollo dentro de Visual Studio 2010.

Estos atajos nos ayuda a ser más productivos a la hora de desarrollar aplicaciones con el IDE de Visual Studio 2010.

Los lenguajes de programación recogidos en estos atajos son C++, C#, F#y VB.

Podrás acceder a la página de descargas de los keybinding cards aquí.