Archivo de la etiqueta: Visual Basic

Te invito a mi fiesta de jubilación

Pues eso… que los de Velneo me han preparado un evento de jubilación para el próximo 18 de junio, así que… lee y ¡apúntate!

 

¡Te invito a mi fiesta de jubilación!

 

Si no puedes ver el vídeo, pulsa en este enlace.

 

¡Ya me han jubilado oficialmente!

Y para que no se pierda nada de elGuille.info, y pueda seguir estando actualizado, lo dejo en buenas manos, las de Velneo.

Aprovecho para invitarte a que participes en mi evento de “jubilación” el próximo 18 de junio a las 17:00 (hora de Madrid).

El Guille

 

Homenaje al legado de El Guille

Esta celebración la organizamos unos pocos, pero lleva la voz de miles: los que aprendimos y crecimos en la programación gracias al trabajo del Guille.

Ahora que se ha retirado, somos nosotros los que debemos corresponderle.

No había pasado ni una hora y el tema ardía en nuestros mensajes y foros: “El Guille se jubila, ¿lo habéis leído?”. A eso le siguieron las reflexiones personales: “yo empecé gracias a sus artículos”, “me ha salvado muchos proyectos”, “ha sido mi facultad de informática”…

De ahí, la conversación derivó a una pregunta evidente:

¿Qué podemos hacer para agradecerle todo lo que ha hecho?

Unos pocos programadores de Velneo, con el apoyo de la empresa, estamos preparando un evento de homenaje a Guillermo, que sienta nuestra gratitud y poder continuar juntos su legado.

Será un evento online interactivo, en el que podrás conversar con el Guille, el 18 de junio a las 17:00 (hora de Madrid).

¿Te sumas?

¡Quiero asistir!

 

Nos vemos.
Guillermo

Usar TaskDialog desde .NET Framework 4

Pues eso, que si quieres usar los cuadros de diálogo de la clase TaskDialog en tus aplicaciones de .NET (C# o Visual Basic) debes usar .NET 5 o superior, al menos para acceder a las clases directamente, pero si te pasa como me pasó ayer a mí que quería usarlo en una aplicación de .NET Framework 4.8.1, pues… sigue leyendo 😉

Esta captura (de la página explicativa de TaskDialog de WindowsControls) te muestra cómo son estos cuadros de diálogo que hicieron su aparición en Windows Vista.

Como ya te he dicho, .NET 5.0 y superior incluye la clase TaskDialog y sus derivados, pero en este caso voy a usar un paquete de NuGet, que está actualizado en este mismo año 2023: WindowsAPICodePack. La versión a la hora de escribir esta entrada en el blog es la v7.0.4 publicada el 26 de febrero de 2023 por Peter William Wagner, (aka Wagnerp).

Para usar las clases agrega ese paquete de NuGet a tu proyecto y ya lo tendrás disponible.

Aquí te pongo un código de ejemplo en Visual Basic para usar ese cuadro de diálogo de forma parecida a como usarías MessageBox.Show.

''' <summary>
''' Mostrar el cuadro de diálogo usando TaskDialog.
''' </summary>
''' <param name="header">El texto de cabecera.</param>
''' <param name="texto">El texto principal.</param>
''' <param name="caption">El texto de la ventana.</param>
''' <param name="buttons">Los botones a mostrar.</param>
''' <param name="icon">El icono a mostrar.</param>
''' <returns>Un valor de tipo TaskDialogResult.</returns>
Public Shared Function MostrarDialogo(header As String, texto As String, Optional caption As String = Nothing,
                                      Optional buttons As TaskDialogStandardButtons = TaskDialogStandardButtons.Ok,
                                      Optional icon As TaskDialogStandardIcon = TaskDialogStandardIcon.Information) As TaskDialogResult
    If String.IsNullOrEmpty(caption) Then
        caption = header
    End If

    Dim taskDialogMain As TaskDialog = New TaskDialog With {
        .Caption = caption,
        .InstructionText = header,
        .Text = texto,
        .Cancelable = True,
        .StandardButtons = buttons,
        .Icon = icon
    }
    Dim tdr As TaskDialogResult = taskDialogMain.Show()
    Return tdr
End Function

Y la forma de usar este método sería algo así:

If fPrincipal.MostrarDialogo("Cerrar VentasPlayaWin",
                             "¿Seguro que quieres cerrar la aplicación de VentasPlayaWin?",
                             Nothing,
                             Microsoft.WindowsAPICodePack.Dialogs.TaskDialogStandardButtons.Yes Or Microsoft.WindowsAPICodePack.Dialogs.TaskDialogStandardButtons.No,
                             Microsoft.WindowsAPICodePack.Dialogs.TaskDialogStandardIcon.Warning) = Microsoft.WindowsAPICodePack.Dialogs.TaskDialogResult.Yes Then

    Me.Close()
    fPrincipal.Current.Close()

End If

En este caso, fPrincipal es la clase donde está definido el método MostrarDialogo mostrado anteriormente.

No es tan intuitivo como las clases de .NET, ya que es más al estilo del API de Windows, pero… para salir del paso te puede servir y ya es cuestión tuya simplificar los botones, iconos, etc.

Si tengo tiempo prepararé un proyecto tanto para Visual Basic como C# con ejemplos de cómo usar las otras opciones de las notas al pie, enlaces, etc. Pero mientras tanto puedes ver los ejemplos de cómo usar esta API en GitHub: Windows-API-Code-Pack-1.1.

Los ejemplos concretos de TaskDialog para Visual Basic y C# están en esta carpeta: TaskDialogDemo.

Espero que te sea de utilidad. 😊

Ya sabes si quieres hacer un donativo para seguir manteniendo el blog del Guille, usa este enlace. Gracias 🙏🏻

Nos vemos.
Guillermo

Utilidad para invertir las asignaciones de controles a objeto y viceversa (ReordenarAsignaciones)

Pues eso, hay ocasiones en las que en el código asigno los datos de una tabla a los controles del «formulario» (quien dice formulario dice página XAML, etc.), sí, sé que se puede hacer con DataBinding, pero… casi siempre prefiero usar el modo manual ya que así parece que tengo más control con lo que hago y, de hecho, en algunas ocasiones el DataBinding no va como debería, al menos eso me ha pasado en varias páginas de Xamarin.Forms. No sé si tú lo harás así, pero yo suelo hacerlo con bastante frecuencia, será por la forma de trabajar que tengo. 😊

Te explico:
Digamos que tengo una tabla de una base de datos, que he convertido con la utilidad Generar las clases (de VB o C#) de una tabla de SQL Server o Access (mdb) en la que tengo asignada en una variable (por ejemplo, LaFactura) el contenido de la tabla Facturas y quiero asignar el contenido de ese objeto a los diferentes controles, haría algo como esto para asignar los valores de LaFactura a los controles:

/// <summary>
/// Mostrar la factura en los campos.
/// </summary>
private void MostrarLaFactura()
{
    chkFacActiva.IsChecked = LaFactura.Activa;
    txtFacActividad.Text = LaFactura.Actividad;
    txtFacAdultos.Text = LaFactura.Adultos.ToString();
    txtFacAgente.Text = LaFactura.Agente;
    txtFacCuantasReservas.Text = LaFactura.CuantasReservas.ToString();
    txtFacCuantosPagos.Text = LaFactura.CuantosPagos.ToString();
    txtFacDescuento.Text = LaFactura.Descuento.ToString("0.##");
    txtFacFechaFactura.Text = LaFactura.FechaFactura.ToString("dd/MM/yyyy HH:mm");
    txtFacHoraActividad.Text = LaFactura.HoraActividad.ToString("hh\\:mm");
}

Y tengo este otro método para hacer el caso contrario (asignar al objeto LaFactura el valor de los controles):

/// <summary>
/// Asignar los campos a la factura para guardar.
/// </summary>
/// <returns>True si algo no va bien.</returns>
private bool AsignarLaFactura()
{
    LaFactura.Activa = chkFacActiva.IsChecked;
    LaFactura.Actividad = txtFacActividad.Text;
    LaFactura.Adultos = txtFacAdultos.Text.AsInteger();
    LaFactura.Agente = txtFacAgente.Text;
    LaFactura.CuantasReservas = txtFacCuantasReservas.Text.AsInteger();
    LaFactura.CuantosPagos = txtFacCuantosPagos.Text.AsInteger();
    LaFactura.Descuento = txtFacDescuento.Text.AsDecimal();
    LaFactura.FechaFactura = txtFacFechaFactura.Text.AsDateTime();
    LaFactura.HoraActividad = txtFacHoraActividad.Text.AsTimeSpan();

    return false;
}

En el método MostrarLaFactura las asignaciones las hago de la forma habitual, es decir, asigno a los controles los datos que quiero mostrar, por ejemplo, si es fecha le asigno de la forma dd/MM/yyyy, etc.

El caso especial es cuando lo hago al revés: AsignarLaFactura, que debo convertir el contenido de los controles al formato adecuado, en este caso utilizo para las fechas, horas y cifras con decimales unos métodos de extensión que tengo definidos para hacer esa tarea (que empiezan con As y tienen el formato AsTIPODATOS), esto último no es parte de la utilidad que me he fabricado, pero… la tiene en cuenta 😉

Hacer esto manualmente, que es como lo hacía hasta hace 2 días, es tedioso y, por supuesto se pueden producir errores, que modificas tras el aviso de Visual Studio, pero… es, ¿cómo decirlo?, un peñazo por no decir co**zo. 😊

Y me puse a fabricarme una utilidad (sí, en C#) para hacer eso, por ahora es muy simple y en las asignaciones no contempla que haya comentarios, pero… todo se andará.

Las asignaciones que convertir se indican como argumentos en la línea de comandos, yo lo que hago es tener el proyecto abierto en Visual Studio y en la parte de DEBUG le asigno lo que se indicará en la línea de comandos (ver la captura 1), al hacerlo de esta forma (indicando los valores a convertir como argumentos de la aplicación), hay que tener en cuenta que los valores asignados al array args del método Main se hacen de esta forma:
ladoIzquierdo = ladoDerecho, de forma que si pones: chkFacActiva.IsChecked = LaFactura.Activa; esta será las asignaciones al array args:
args[0] = "chkFacActiva.IsChecked"
args[1] = "="
args[2] = "LaFactura.Activa;"

Y esto es lo que tengo en cuenta, por eso aún no contemplo los comentarios, ya que analizo el contenido del array args de tres en tres valores:

for (int i = 0; i < args.Length - 2; i += 3)

Pero eso ya lo arreglaré en la próxima revisión.

Figura 1. Los argumentos de la línea de comandos del proyecto

 

Dicho esto, no me queda mucho más que decir 😊

Solo ponerte el enlace al proyecto publicado en GitHub: ReordenarAsignaciones, el nombre en realidad tendría que ser InvertirAsignaciones, pero… así es como lo creé inicialmente y… seguramente se quedará así 😉

Nota:
En el repositorio de GitHub incluyo las clases con las extensiones que te he comentado y muchas más.
El código de Extensiones está tanto para Visual Basic (el original) como para C# (el convertido).

También he creado un paquete de NuGet que he definido como Tool de .NET 6 de forma que lo puedas instalar si tienes instalado el SDK de .NET 6 o superior.
De esa forma lo podrás tener como una utilidad de .NET y no preocuparte de instalarlo (extraer el código ejecutable en una carpeta) y asignar el path a ese directorio para poder usarla desde cualquier línea de comandos.

El paquete de NuGet se llama igual: ReordenarAsignaciones y este enlace te llevará a la página de NuGet donde tengo ese «paquete».
Notar que no es necesario instalarlo en un proyecto de Visual Studio, simplemente instalarlo usando la línea de comandos:
dotnet tool install --global ReordenarAsignaciones --version 1.2.0
Esto te instalará la versión que tengo a la hora de escribir esto, pero en la página de NuGet te muestra siempre qué tienes que hacer para instalarlo.

Para actualizar el «paquete» siempre es el mismo código independientemente de la versión:
dotnet tool update --global ReordenarAsignaciones

 

Espero que te sea de utilidad, esa es la intención 😉

Y si te parece bien, acuérdate de invitarme a un cafelito virtual mediante un donativo/donación con PayPal. Usando este enlace o este código QR:

Gracias 🙏🏻

Nos vemos.
Guillermo