Archivo de la etiqueta: dotnet

Adiós Visual Studio 2019, adiós (¡ahí te quedas con tus marrones!)

Pues eso… actualmente utilizo el Visual Studio 2022 para los proyectos y anoche abrí uno que creé con el Visual Studio 2017 para .NET Framework, y vi que no me mostraba el contenido de los formularios, es decir, se mostraba como si no tuviesen controles dentro, así que… lo abrí el Visual Studio 2019 y… me mostró el aviso de que ya no tiene soporte (ver la captura) y que utilice el Visual Studio 2022… ¡ja! ¿Y qué hago con todos los proyectos que tengo para .NET Framework o para .NET 5?

Imagen 1. Visual Studio 2019 ya no tiene soporte

Así que… ¿qué hacemos con los proyectos creados para .NET Framework? (aparte de convertirlos para .NET 6.0 o posterior) o ¿qué hacemos con los proyectos para .NET 5 (y anteriores)? (aparte de convertirlos para .NET 6.0 o posterior)

Habrá que investigarlo… pero eso será en otra ocasión… que ahora tengo que empezar a currar… 😉

Nos vemos.
Guillermo

Serializar/deserializar con Json.Serialization (ejemplo para C#)

Pues eso… ahora esto de los ficheros con la extensión .json es lo que está en la «onda» y… pues habrá que aprovecharlo que incluso es fácil usarlo en las aplicaciones de .NET.

Espero que no sirva de precedente, pero en este post no hay ejemplo para Visual Basic, solo para C#. No es porque yo abandone mis END IFs y me pase definitivamente a las llaves y puntos y comas, es porque acabo de terminar una clase «serializable» y la he escrito en C# y por vagancia, no he querido crear un ejemplo en Visual Basic. Eso sí, esta clase la utilizo desde código de Visual Basic, ya que en C# solo he hecho la clase, y como he comprobado que los ejemplos que he consultado no hacían bien el trabajo, me he decidido a escribir esta entra en el blog (post).

La clase que serializo es muy simple, es para «recordar» los tamaños de las columnas de, en mi caso, un DataGridView. Esa cuadrícula utiliza distintos tipos de nombres y anchos de columnas, por tanto, el objeto que contiene los valores está formado por un diccionario en el que la clave es una cadena (string), para saber el tipo de datos mostrados, y los valores es otro diccionario de tipo entero en la clave y el valor que guardará serán el índice de la columna y el ancho de la misma.

Esa propiedad está definida de la siguiente forma:

/// <summary>
/// Diccionario para el tipo de listado y los valores de cada columna 
/// (por índice) y el ancho de la columna.
/// </summary>
[JsonPropertyName("anchos")]
public Dictionary<string, Dictionary<int, int>> Anchos { get; set; } = new();

El atributo JsonPropertyName es el que le indica al compilador que esa propiedad es serializable y que está enlazada con el valor anchos del fichero .json.

Esta es la parte fácil.

Ahora hay que leer y guardar los datos en el fichero de texto con la extensión que queramos, pero que en este ejemplo utilizo el valor estándar: .json.

Y estos son los métodos principales para guardar (Save) y leer (Load) el contenido de la clase en el fichero. Save guarda el contenido de la clase en el fichero (lo serializa) y Load lee el contenido del fichero (lo de-serializa) y lo asigna a un objeto del tipo de la clase del tipo donde está definida esa propiedad. No te líes. Es más sencillo el código que explicar lo que hace… 😉

/// <summary>
/// Carga los valores del fichero indicado.
/// </summary>
/// <param name="fileName">El path del fichero a leer y devolver el contenido.</param>
/// <returns>El objeto leído del fichero indicado.</returns>
private static AnchoColumnas Load(string fileName)
{
    // Abrir el fichero para leer, compartido para lectura y escritura.
    using var stream = new FileStream(fileName, 
                                      FileMode.OpenOrCreate, 
                                      FileAccess.Read, 
                                      FileShare.ReadWrite);
    // Si tiene contenido, deserializarlo, si no, devolver un valor nulo.
    if (stream.Length > 0)
        return JsonSerializer.Deserialize<AnchoColumnas>(stream);
    else
        return null;
}

/// <summary>
/// Guarda los datos de tipo AnchoColumnas indicado.
/// </summary>
/// <param name="anchosColumnas"></param>
/// <param name="fileName"></param>
/// <returns></returns>
private static void Save(AnchoColumnas anchosColumnas, string fileName)
{
    // Abrir el fichero para escribir, compartido para lectura y escritura.
    using var stream = new FileStream(fileName, 
                                      FileMode.OpenOrCreate, 
                                      FileAccess.Write, 
                                      FileShare.ReadWrite);
    // Que se indente el contenido.
    var options = new JsonSerializerOptions { WriteIndented = true };
    // Guardar (serializar) el contenido de la clase.
    JsonSerializer.Serialize<AnchoColumnas>(stream, anchosColumnas, options);
}

En mi caso, he creado otros dos métodos llamados Guardar y Leer en el que asigno el nombre del fichero que contendrá los datos serializados de la clase.
Ese fichero está en el path del ejecutable.

Este es el código:

/// <summary>
/// Guardar los datos de los anchos de los listados.
/// </summary>
/// <param name="anchosColumnas"></param>
public static void Guardar(AnchoColumnas anchosColumnas)
{
    // El fichero está en la carpeta del ejecutable.
    var fic = Path.Combine(Application.StartupPath, "AnchosColumnas.json");
    Save(anchosColumnas, fic);
}

/// <summary>
/// Leer los anchos de las columnas.
/// </summary>
/// <returns></returns>
public static AnchoColumnas Leer()
{
    // El fichero está en la carpeta del ejecutable.
    var fic = Path.Combine(Application.StartupPath, "AnchosColumnas.json");
    return Load(fic);
}

Como puedes comprobar, el método Guardar recibe como parámetro la clase a serializar y el método Leer devuelve un objeto con la clase deserializada (o un valor nulo en caso de que aún no tenga contenido el fichero).

La parte interesante está en los métodos Save y Load, ya que utilizo código «seguro» a la hora de leer o escribir en un fichero que no exista.
Y el truco está en crear el objeto de tipo Stream usando FileStream en lugar de usar los métodos OpenRead u OpenWrite de la clase File, ya que, para usar esos dos métodos habría que hacer comprobaciones si existen, si están compartidos, etc., etc., etc.

Por último, en esa misma clase tengo un método (también compartido o estático) para acceder a la información. Es una propiedad de solo lectura, que se encarga de asignar/leer el objeto si debe hacerlo (cuando inicialmente no está asignado).

Este es el código:

private static AnchoColumnas _AnchosColumnas = null;
/// <summary>
/// Los anchos de las columnas de los listados.
/// </summary>
public static AnchoColumnas AnchosColumnas
{
    get
    {
        if (_AnchosColumnas == null)
        {
            _AnchosColumnas = Leer();
            if (_AnchosColumnas == null)
            {
                _AnchosColumnas = new();
            }
        }
        return _AnchosColumnas;
    }

Y finalmente te muestro cómo uso esa clase desde el código que tengo en Visual Basic:

Primero para asignar las columnas al objeto DataGridView (en el código indicado por lvDatos) y después cuándo guardar los nuevos valores, cosa que hago en el evento ColumnWidthChanged.

La asignación de los anchos guardados lo hago en un método (con más código del mostrado) en el que asigno los valores de las columnas, tanto el texto a mostrar como el ancho, y por supuesto el número de las mismas.

Este es el código para leer los valores guardados y asignarlos a las columnas del objeto lvDatos:

' Asignar los anchos que estén guardados.           (22/abr/22 20.34)
If AnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value.ToString()) = False Then
    AnchoColumnas.AnchosColumnas.Anchos.Add(value.ToString(),
                                            New Dictionary(Of Integer, Integer))
End If
Dim cols = AnchoColumnas.AnchosColumnas.Anchos(value.ToString())
If cols.Keys.Count = 0 Then
    For i = 0 To lvDatos.Columns.Count - 1
        cols.Add(i, lvDatos.Columns(i).Width)
    Next
Else
    For i = 0 To cols.Keys.Count - 1
        lvDatos.Columns(i).Width = cols(i)
    Next

d End If

El valor de la variable «value» es el nombre de la enumeración que utilizo y que es un valor asignado como parámetro de este método (recuerda que esto es solo un extracto en el que se asignan los valores leídos, si es que existe el fichero con esos valores ya guardados).

Y para finalizar, el código del evento ColumnWidthChanged, en el que, tengo puesto una comprobación de si se está inicializando (cuando se carga el formulario) con idea de que no se guarden los valores iniciales que tenga.

Private Sub lvDatos_ColumnWidthChanged(sender As Object, e As DataGridViewColumnEventArgs) Handles lvDatos.ColumnWidthChanged
    ' Cambiar el ancho de las columnas de los totales       (10/mar/22 04.28)
    ' al cambiar el del principal.
    If inicializando Then Return

    ' Asignar y guardar los valores.                        (22/abr/22 20.39)
    Dim value = TipoListado.ToString()
    With lvDatos
        If AnchoColumnas.AnchosColumnas.Anchos.ContainsKey(value) = False Then
            AnchoColumnas.AnchosColumnas.Anchos.Add(value, New Dictionary(Of Integer, Integer))
        End If
        ' Asegurarse que se asignan correctamente.
        Dim cols = AnchoColumnas.AnchosColumnas.Anchos(value)
        cols.Clear()
        For i = 0 To .Columns.Count - 1
            cols.Add(i, .Columns(i).Width)
        Next
        AnchoColumnas.Guardar(AnchoColumnas.AnchosColumnas)
    End With
End Sub

Y esto es todo… otro día pondré el código para Visual Basic de la clase y un ejemplo de cómo usarla escrito en C#, pero eso será en otra ocasión 😉

Nos vemos.
Guillermo

Saber las unidades externas (USB pendrive fijo o extraíble)

Pues eso… yo pensaba que todas las unidades (de tipo pendrive) USB devolverían un valor del tipo DriveType.Removable, pero resulta que no. Al igual que ocurre con los discos duros conectados por USB, los pendrives también pueden ser de tipo fijo (DriveType.Fixed).

Y lo que te voy a mostrar es el código para C# y Visual Basic (usando .NET 5.0 con Visual Studio 2019) para saber todas las unidades conectadas por USB (sean fijas o extraíbles), además de una función para saber si el path indicado está o no en una unidad extraíble.

También incluyo un ejemplo de cómo saber las unidades (y el tipo de unidad que es) usando el «clásico» método para saber las unidades instaladas con DriveInfo.GetDrives().

En la siguiente captura puedes ver el programa funcionando en mi equipo.

Imagen 1. El programa funcionando.

En mi equipo tengo conectado 2 discos duros por usb (letras S y T), un pendrive de tipo fijo (letra F) y uno de tipo extraíble (letra G).

En la primera lista (usando el método GetDrives de la clase DriveInfo) el único que se muestra como «extraíble» es el disco G, el resto se muestran como fijos (fixed).
En la segunda lista se muestran las unidades extraíbles, sean o no fijas.

Ya sin más rollos te muestro el código tanto para C# como para Visual Basic.

El código lo puedes descargar de GitHub (UnidadesExternas), pero si quieres crearlo por tu cuenta, decirte que he tenido que añadir una referencia al paquete de Nuget System.Management versión 5.0 ya que estos proyectos los he creado con Visual Studio 2019 y esa versión de Visual Studio no utiliza versiones posteriores a .NET 5.0.

El tipo de proyecto es Consola de Windows, aunque he tenido que cambiar el tipo del proyecto, ya que al elegir que sea para .NET 5.0 ha intentado usarlo para cualquier plataforma.
En el fichero del proyecto (de C# o de VB) busca <TargetFramework> y cambia net5.0 por net5.0-windows, ya que System.Management solo se puede usar en el sistema operativo Windows.

 

Nota:
Comentarte que el código (de C#) está basado en dos ejemplos encontrados en la red y de esos dos códigos de ejemplo he sacado el código del método GetUsbDriveLetters.
Estos son los enlaces que he usado:
El primero es prácticamente el usado en ese código, pero añadiendo la comprobación de que MediaType también pueda ser External, que saqué del segundo.
https://stackoverflow.com/a/31560283/14338047
https://stackoverflow.com/a/10018438/14338047

 

Código de C# de la utilidad para saber las unidades externas

public class USBUtil
{
    /// <summary>
    /// Comprueba si es una unidad externa.
    /// </summary>
    /// <param name="elPath">Path completo del que se extraerá la letra de unidad.</param>
    /// <returns></returns>
    public static bool EsUnidadExterna(string elPath)
    {
        var disco = Path.GetPathRoot(Path.GetFullPath(elPath));
        var usbD = GetUsbDriveLetters();
        return usbD.Contains(disco);
    }

    // Código basado en dos ejemplos de "la red".
    // https://stackoverflow.com/a/31560283/14338047
    // https://stackoverflow.com/a/10018438/14338047

    /// <summary>
    /// Las letras de las unidades externas conectadas por USB.
    /// </summary>
    /// <returns></returns>
    public static List<string> GetUsbDriveLetters()
    {
        // Hay que usar External para que también tenga en cuenta los USB de tipo fijo.
        var usbDrivesLetters = from drive in new ManagementObjectSearcher("select * from Win32_DiskDrive WHERE MediaType like '%External%' OR InterfaceType='USB'").Get().Cast<ManagementObject>()
                               from o in drive.GetRelated("Win32_DiskPartition").Cast<ManagementObject>()
                               from i in o.GetRelated("Win32_LogicalDisk").Cast<ManagementObject>()
                               select string.Format("{0}\\", i["Name"]);

        return usbDrivesLetters.ToList();
    }

}

 

Código de Visual Basic de la utilidad para saber las unidades externas

Public Class USBUtil

    ''' <summary>
    ''' Comprueba si es una unidad externa.
    ''' </summary>
    ''' <param name="elPath">Path completo del que se extraerá la letra de unidad.</param>
    ''' <returns></returns>
    Public Shared Function EsUnidadExterna(elPath As String) As Boolean
        Dim disco = Path.GetPathRoot(Path.GetFullPath(elPath))
        Dim usbD = GetUsbDriveLetters()
        Return usbD.Contains(disco)
    End Function

    ''' <summary>
    ''' Las letras de las unidades externas conectadas por USB.
    ''' </summary>
    ''' <returns></returns>
    Public Shared Function GetUsbDriveLetters() As List(Of String)
        ' Hay que usar External para que también tenga en cuenta los USB de tipo fijo.
        Dim usbDrivesLetters = From drive In New ManagementObjectSearcher("select * from Win32_DiskDrive WHERE MediaType like '%External%' OR InterfaceType='USB'").[Get]().Cast(Of ManagementObject)()
                               From o In drive.GetRelated("Win32_DiskPartition").Cast(Of ManagementObject)()
                               From i In o.GetRelated("Win32_LogicalDisk").Cast(Of ManagementObject)()
                               Select String.Format("{0}\", i("Name"))
        Return usbDrivesLetters.ToList()
    End Function

 

Nota:
Debes añadir importación de los espacios de nombres:
System
System.Collections.Generic
System.IO
System.Linq
System.Management (de NuGet)

 

Código de ejemplo usar estas los métodos de USBUtil.

class Program
{
    static void Main(string[] args)
    {
        Console.Title = "Ejemplo de Visual C# usando .NET 5.0 (net5.0-windows) y System.Management Version=5.0.0";

        Console.WriteLine("Mostrar las unidades usando DriveInfo.GetDrives().");
        foreach (var dr in DriveInfo.GetDrives())
            Console.WriteLine("Unidad: {0}, tipo: {1}", dr.Name, dr.DriveType);

        Console.WriteLine();

        Console.WriteLine("Mostrar las unidades extraíbles.");
        var usb = USBUtil.GetUsbDriveLetters();
        foreach (var s in usb)
            Console.WriteLine("{0}", s);

        Console.WriteLine();
        Console.ReadKey();
    }

Module Program
    Sub Main(args As String())
        Console.Title = "Ejemplo de Visual Basic usando .NET 5.0 (net5.0-windows) y System.Management Version=5.0.0"

        Console.WriteLine("Mostrar las unidades usando DriveInfo.GetDrives().")
        For Each dr In DriveInfo.GetDrives()
            Console.WriteLine("Unidad: {0}, tipo: {1}", dr.Name, dr.DriveType)
        Next
        Console.WriteLine()

        Console.WriteLine("Mostrar las unidades extraíbles.")
        Dim usb = USBUtil.GetUsbDriveLetters()

        For Each s In usb
            Console.WriteLine("{0}", s)
        Next

        Console.WriteLine()
        Console.ReadLine()
    End Sub
End Module

Y esto es todo, espero te resulte de utilidad 😉

Nos vemos.
Guillermo

Lo que no me gusta de Visual Basic .NET (con Visual Studio)

Pues eso… a pesar de los pesares, hay algo bueno al crear los proyectos para Visual C# desde Visual Studio que en Visual Basic (por aquello de que debemos estar protegidos de tocar donde no se debe, o eso supongo). Es algo muy simple, que introdujeron (creo) en Visual Studio 2005 y es lo de que el método Sub Main sea autogenerado por el Visual Studio y no te permita crear uno propio… o al menos eso me ha pasado con Visual Studio 2022 Version 17.2.0 Preview 1.0 y al final he tenido que crear el proyecto con C# para poder poner lo que me dé la gana en el método Main. En fin…

Y es que, aunque haya definido mi propio método Sub Main, el Visual Studio me daba error de compilación de que ya estaba definido (o estaba definido más de una vez), no recuerdo bien qué me dijo… pero corté por lo sano, descarté el proyecto de Visual Basic y lo creé con C# (para .NET 6.0 y Windows Desktop).
Ese proyecto solo se encarga de llamar a otro que es el principal y por tanto, lo que necesitaba hacer es poder llamar al formulario adecuado para que se iniciara ahí la aplicación (el que tengo definido en otro proyecto diferente al de inicio).
Esto es para poder tener proyectos de inicio diferentes para cada «cliente» que quiera usar mi aplicación. Y en esos proyectos asignar los parámetros personalizados de cada cliente. Todo esto último, solo para aclarar. 😉

Buscaré en la documentación si hay alguna forma de «pasar» de esta automatización (que, seguro que la hay, desde el propio Visual Studio, ya que creando el proyecto desde la línea de comandos con dotnet seguro que se puede). Y si la hay ya te lo contaré.

Nota:
Antes de publicar esto, he probado a crear un proyecto con dotnet:
He creado el directorio con el nombre del proyecto, he cambiado a ese directorio y he escrito esto en la línea de comandos:
dotnet new winforms -lang VB -f net6.0
Y el proyecto se ha creado con el fichero Program.vb (con la definición de Sub Main) y un formulario Form1. Y ahora no dice nada el Visual Studio si lo cargo. Creo que el truco está en no crear los directorios ni asignaciones a My Project, etc.
Lo probaré desde Visual Studio a ver…

Nota 2:
Para solucionar esto en un proyecto creado desde Visual Studio.
He seguido estos pasos:
He comentado (también las puedes borrar) las secciones (cada una está dentro de <ItemGroup>) :
<Compile Update="My Project\Application.Designer.vb"> y
<None Update="My Project\Application.myapp">.

He comentado <MyType>WindowsForms</MyType> en el ItemGroup principal y de paso he eliminado la carpeta My Project. Y el fichero ApplicationEvents.vb.
Esto realmente es lo que da el problema de que haya dos Sub Main.

Y finalmente he creado un fichero Program.vb con el código «personalizado» para Sub Main.
En fin… complicaciones por intentar facilitar las cosas a los que preferimos Visual Basic.

Figura 1. Para quitar el error debes comentar MyType.

Nota 3:
Aunque los proyectos de C# creados con Visual Studio también tienen código autogenerado… por ejemplo: ApplicationConfiguration.Initialize.
Que lo que hace es lo que siempre (o casi) han hecho los métodos Main de las aplicaciones de Windows Forms:
public static void Initialize()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.SetHighDpiMode(HighDpiMode.SystemAware);
}

Y ya está… tenía que decirlo y lo he dicho 😉

Nos vemos.
Guillermo

Lo que estoy maquinando sobre expresiones lambda (métodos anónimos), programación asíncrona (tareas en otros hilos), cancelación de tareas, Parallel.For, consultas LINQ, DataGridView virtual y más, tanto para C# como para Visual Basic

Pues eso… ¡peasso de título! y seguramente se me olvidará algo, por eso he puesto al final «y más». Pero la idea que tengo en mente hoy 24 de febrero de 2022 (con la guerra de Ucrania fresquita, aunque es algo que, lamentablemente no es tan fresca y que ya viene de largo), es explicarte en una serie de posts o entradas en el blog todo lo indicado en el título.

Sobre las expresiones lambda o métodos anónimos, he pensado en ponerte un par de videos que Héctor de León publicó a principios del año pasado en su canal de YouTube (HDELEON.NET), pero como el código que él utiliza es para C# .NET, te mostraré también el equivalente para VB.NET así, si eres de los que utilizan C# lo puedas entender mejor. Todo esto contando con que él me autorice mostrar su código de C# y el equivalente (en la medida de lo posible) de Visual Basic para punto NET.
Actualización de las 17:33: Autorización que ya me ha dado 😉 ¡Gracias Héctor!

En cuanto a la programación asíncrona, te explicaré cómo crear tareas en otros hilos (principalmente con Task.Run) y el uso de async y await. Esas tareas se lanzarán o se procesarán también en el hilo principal de una aplicación de tipo Windows Forms (todo el código creado para .NET Core versiones 5 y/o 6) de forma que sepas qué cosas debes saber para el uso de controles, etc. entre hilos, cosa que solucionaré con InvokeRequired y la llamada a un delegado mediante Invoke. Por supuesto verás cómo definir delegados y cómo usarlos en el código.
Con todo esto verás cómo acceder a parte del código que se ejecuta en el hilo principal (el creado para mostrar el formulario de inicio) desde otro hilo (o tarea).

También verás cómo cancelar esas tareas y cómo controlarlas, todo ellos mediante el uso de objetos CancellationTokenSource y CancellationToken (tanto en su forma normal y anulable). Y lo que debes hacer para comprobar en el código cuando se ha cancelado y cómo tratar esa cancelación, algo que harás pasándole a la tarea (Task) el objeto de tipo CancellationToken.

Y como algunas de las tareas (ya sean asíncronas o no) puede que tenga que acceder a objetos de una colección, verás algunos casos de cómo usar Parallel.For para repartir en tareas el proceso de comprobación del contenido de esa colección.

La mayoría de las cosas que se hará en el código de ejemplo requerirá de las expresiones lambda (o métodos anónimos) y su uso en expresiones de LINQ. Ya sabes: Where, Any, Select, etc.

Por último, parte del código de ejemplo lo haré usando un control DataGridView y en ese caso te mostraré cómo crearlo para usar una caché con los datos que manejará y todo ello usando el modo virtual de ese control, de esa forma, al menos en mi caso, he logrado agilizar (sobre todo acelerar) mostrar los datos en ese grid (o cuadrícula). La caché usada estará preparada para el tipo de datos que voy a usar en ese ejemplo.

Todo esto, lo iré publicando poco a poco, entre otras cosas, porque lo estoy usando en una aplicación que utiliza datos o tipos muy concretos. Si te sirve de algo, es una aplicación que estoy migrando de MS-DOS a Windows, y la mayoría de los datos los obtiene de ficheros de texto… ¡Sí, así de vieja es! 🙂
Pero haré que el código acceda a colecciones de datos más simples, que en principio no se obtendrá de una base de datos, pero no descarto que también haga alguna modificación para acceder a una base de datos, y si es remota, mejor. Pero eso ya lo veré en su momento.

Bueno, te dejo por ahora y ya iré poniendo cosas… seguramente pondré los enlaces en este mismo post, pero si se me olvida hacerlo… pues… ¡busca en fechas posteriores al 24 de febrero de 2022! 😉

Y ya sabes… si me quieres invitar a un cafelillo o refresco virtual, puedes usar el enlace de DONAR con PayPal. Gracias de antemano.

Nos vemos.
Guillermo

Descargar ficheros de un sitio WEB usando HttpClient (ejemplos para VB.NET y C#)

Pues eso… para descargar ficheros de un sitio Web, hasta hoy usaba el método DownloadFile de la clase WebClient, pero ya estaba un poco harto del «warning» de que esa clase (y otras) estaban obsoletas y que era recomendable usar HttpClient, pero… no daba con un ejemplo (de código) práctico y, porque no, sencillo. Mire en varios sitios y de una forma u otra, se complicaba la cosa… hasta que me dio por mirar el contenido de la clase HttpClient en la documentación de .NET (esto me pasa por no fiarme de los ejemplos de la documentación de MS :-P).

Y aquí te muestro lo que he hecho, creo que de forma simple.

El código que te voy a mostrar descarga un fichero de un sitio Web y lo guarda de forma local. Como para este ejemplo he usado un fichero de texto (txt) que tengo alojado en mi sitio (www.elguille.info), en el código de ejemplo hago que se muestre con el Notepad, pero si lo que te descargas es otro tipo de fichero, ya sea una imagen, etc. tendrás que cambiar el código usado en «Process.Start«.

Este código usa async/await para la descarga y para guardarlo localmente. Pero resulta que Visual Basic no permite usar Async en el método Main (C# tampoco, al menos en las versiones anteriores a la 7.1), por tanto, el código de VB.NET es algo diferente al de C# (aparte de los puntos y comas), básicamente porque en VB el método Main no puede ser asíncrono, así que lo he solucionado haciendo una llamada a otro método desde Main y ese otro método si es asíncrono.
Este mismo paso intermedio tendrás que hacerlo si usas una versión de C# que no soporte que Main sea un método de tipo Task asíncrono. En realidad, tendrías que hacer otros cambios en el código de C#, ya que uso nuevas cosas que tampoco estaban en las versiones anteriores…

Básicamente lo que hace el código es crear una instancia «estática/compartida» de un nuevo objeto del tipo HttpClient y después usarlo en el código. Esto en este ejemplo concreto no es necesario, ya que una vez que se utilice ese objeto el programa prácticamente finaliza, pero… es lo que recomiendan: que solo se use una instancia en la aplicación.

Para la descarga, utilizo el método GetByteArrayAsync al que se le indica la dirección URL donde está el fichero en cuestión (o una página WEB si esa es la idea, la de descargar una página Web), ese método devuelve un array de tipo Byte, que usaremos para guardarlo en el fichero local, esto se consigue con WriteAsync de la clase FileStream, en cuyo constructor, entre otras cosas, indicaremos el path local.

El que haya usado GetByteArrayAsync es porque mi código original no descarga un contenido «normal» de tipo cadena, pero para el caso, también sirve. Y de esta forma podrás usar el método que he definido para esta tarea de descargar/guardar (DownloadFileAsync) para cualquier tipo de contenido.

Y ya, no me enrollo más y te muestro el código.

Nota:
Aunque sea más código, te muestro TODO el código, incluyendo las importaciones, etc.

El código de ejemplo para Visual Basic.NET

'--------------------------------------------------------------------------------
' Descargar un fichero de un sitio web usando HttpClient        (10/Feb/22 19.05)
'
' Ejemplo basado en:
' https://docs.microsoft.com/en-us/dotnet/api/system.net.http.httpclient
'
' (c) Guillermo Som (Guille), 2022
'--------------------------------------------------------------------------------
Imports System
Imports System.Diagnostics
Imports System.Threading.Tasks

Module Program

    ''' <summary>
    ''' El objeto HttpClient se recomiendo instanciarlo solo 1 vez en la aplicación.
    ''' </summary>
    Private ReadOnly ClienteHttp As New System.Net.Http.HttpClient()

    Sub Main(args As String())
        'Console.WriteLine("Hello World!")

        ' Como en VB no se puede esperar en Main,
        ' hacer el trabajo asíncrono en otro método y esperar a que se termine todo...
        descargar()

        Console.ReadLine()
    End Sub

    Private Async Sub descargar()
        Dim ficWeb = "https://www.elguille.info/pruebaGuille.txt"
        Dim ficLocal = "prueba.txt"

        Console.WriteLine("Descargando {0}...", ficWeb)

        Dim res = Await DownloadFileAsync(ficWeb, ficLocal)
        If res Then
            Console.WriteLine("Descarga completada.")

            ' Mostrar el contenido del fichero local.
            Process.Start("notepad", ficLocal)
        End If

        Console.WriteLine()
        Console.WriteLine("Pulsa INTRO para finalizar.")
    End Sub

    ''' <summary>
    ''' Descarga el fichero indicado (url) y lo guarda en el fichero destino (usando HttpClient).
    ''' </summary>
    ''' <param name="ficWeb">El fichero a descargar (de una dirección URL).</param>
    ''' <param name="ficDest">El fichero de destino, donde se guardará el descargado.</param>
    ''' <returns>True o false según haya tenido éxito la descarga o no.</returns>
    Public Async Function DownloadFileAsync(ficWeb As String, ficDest As String) As Task(Of Boolean)
        Try
            ' Simplificando la descarga.
            Dim contenido = Await ClienteHttp.GetByteArrayAsync(ficWeb)
            ' Si se ha podido descargar.
            If contenido IsNot Nothing AndAlso contenido.Length > 0 Then
                ' Guardarlo en el fichero de destino.
                ' Si el fichero destino existe, se sobreescribe.
                Using fs As New System.IO.FileStream(ficDest, System.IO.FileMode.Create,
                                                              System.IO.FileAccess.Write,
                                                              System.IO.FileShare.None)
                    Await fs.WriteAsync(contenido.AsMemory(0, contenido.Length))
                End Using
            Else
                Console.WriteLine("No se ha podido descargar.")
                Return False
            End If
        Catch ex As Exception
            ' Se ha producido un error al descargar o guardar.
            Console.WriteLine("Error: {0}", ex.Message)
            Return False
        End Try

        Return True
    End Function

End Module

El código de ejemplo para C#

//--------------------------------------------------------------------------------
// Descargar un fichero de un sitio web usando HttpClient        (10/Feb/22 19.25)
//
// Ejemplo basado en:
// https://docs.microsoft.com/en-us/dotnet/api/system.net.http.httpclient
//
// (c) Guillermo Som (Guille), 2022
//--------------------------------------------------------------------------------

using System;
using System.Diagnostics;
using System.Threading.Tasks;

namespace Descargar_Fichero_con_HttpClient_CS
{
    class Program
    {
        /// <summary>
        /// El objeto HttpClient se recomiendo instanciarlo solo 1 vez en la aplicación.
        /// </summary>
        private readonly static System.Net.Http.HttpClient ClienteHttp = new();

        // En C# 7.1 y superior se puede usar Main como Task y async.
        static async Task Main(string[] args)
        {
            //Console.WriteLine("Hello World!");

            var ficWeb = "https://www.elguille.info/pruebaGuille.txt";
            var ficLocal = "prueba.txt";

            Console.WriteLine("Descargando {0}...", ficWeb);

            var res = await DownloadFileAsync(ficWeb, ficLocal);
            if (res)
            {
                Console.WriteLine("Descarga completada.");

                // Mostrar el contenido del fichero local.
                Process.Start("notepad", ficLocal);
            }

            Console.WriteLine();
            Console.WriteLine("Pulsa INTRO para finalizar.");



            // Las versiones de C# anteriores a 7.1 no pueden esperar en Main,
            // por tanto, el código anterior ponerlo en un método y llamarlo desde aquí
            // y esperar a que se termine todo...
            //descargar();

            Console.ReadLine();
        }

        /// <summary>
        /// Descarga el fichero indicado (url) y lo guarda en el fichero destino (usando HttpClient).
        /// </summary>
        /// <param name="ficWeb">El fichero a descargar (de una dirección URL).</param>
        /// <param name="ficDest">El fichero de destino, donde se guardará el descargado.</param>
        /// <returns>True o false según haya tenido éxito la descarga o no.</returns>
        public async static Task<bool> DownloadFileAsync(string ficWeb, string ficDest)
        {
            try
            {
                // Simplificando la descarga.
                var contenido = await ClienteHttp.GetByteArrayAsync(ficWeb);
                // Si se ha podido descargar.
                if (contenido != null && contenido.Length > 0)
                {
                    // Guardarlo en el fichero de destino.
                    // Si el fichero destino existe, se sobreescribe.
                    using System.IO.FileStream fs = new(ficDest, System.IO.FileMode.Create, 
                                                                 System.IO.FileAccess.Write, 
                                                                 System.IO.FileShare.None);
                    await fs.WriteAsync(contenido.AsMemory(0, contenido.Length));
                }
                else
                {
                    Console.WriteLine("No se ha podido descargar.");
                    return false;
                }
            }
            catch (Exception ex)
            {
                // Se ha producido un error al descargar o guardar.
                Console.WriteLine("Error: {0}", ex.Message);
                return false;
            }

            return true;
        }
    }
}

Y esto es todo… recuerda pulsar en el botoncito ese de PayPal si así lo crees conveniente 😉

Nos vemos.
Guillermo

P.S.
El código lo puedes ver/descargar del repositorio de GitHub que he creado para este caso.

Si instalas VS2022 y VS2019 deja de funcionar… (no carga todos los proyectos)

Pues eso… esto que te cuento ya lo publiqué en mi página de Facebook el pasado día 8 de noviembre (hoy es 23), pero «bicheando» en la WEB he visto que está expuesto este problema de forma más generalizada de lo que esperaba, y hasta gente de Microsoft han dicho que es bueno que esto se comparta para que haya menos gente que se encuentren con estos problemas (según parece esto lo han solucionado o lo van a solucionar en los instaladores de las nuevas versiones de Visual Studio 2022.

Como te comentaba en el post de Facebook, a mí el error que me dio fue: «The project file cannot be opened. Unable to locate the .NET SDK.«.

Esta es la entrada «ligada» al post en la página de Facebook de «elguille.info«:

 

 

Y aquí te lo dejo para que sepas cómo solucionarlo si te ocurre… Y si no te he ocurrido ¡chapó! 😉

Nos vemos.
Guillermo

Solución si en Visual Studio 2022 para Windows no te muestra el dispositivo físico en un proyecto para iOS de Xamarin.Forms

Pues eso… que empecé un proyecto de Xamarin Forms en Visual Studio 2022 con los proyectos para Android y Windows (UWP) pero no añadí el de iOS y después me planteé añadirlo porque, aunque yo no lo uso (no me funcionan en mi iPhone 7 Plus) mi hijo David sí le funcionan en su iPhone y en el iPad (David es de los que gustan usar las cosas de Apple, de hecho, está certificado como técnico en todo lo referente a Apple), y me encontré que ahora no me mostraba el «dispositivo» local en la lista de dispositivos, solo los habituales para usar con un Mac en línea.

Ver las capturas 1 y 2 para que así entiendas mejor a lo que me refiero.
En la captura 1 están las opciones que suelen mostrarse si todo está bien, y en la captura 2 se echa en falta el dispositivo físico.

Captura 1. El dispositivo físico aparece en la lista.

Captura 2. El dispositivo físico no aparece en la lista.

Nota:
Además de lo que te cuento aquí, para que se muestren los dispositivos físicos debes tener instalado en tu Windows el iTunes de Apple.

Aparte de lo comentado en la nota anterior, otra cosa que debes tener en tu proyecto para iOS es que haya una referencia a Xamarin.Forms (se me olvidó añadirla y casi me vuelvo loco buscando cómo solucionarlo) y ya, de esas cosas que te dan pro probar… probé a verificar las dependencias del proyecto y eché en falta la referencia a Xamarin.Forms, y fue añadirla y… ¡voilà! ahí está el dispositivo disponible, otra cosa es que funcione la aplicación, pero al menos está 😉

En las capturas 3 y 4 puedes ver las referencias del proyecto para iOS.
En la captura 3 no estaba incluido Xamarin.Forms y por eso no se mostraba el dispositivo físico.
En la captura 4 ya está esa referencia y ahora sí que muestra en la lista de dispositivos (si está conectado al USB del equipo, todo hay que aclararlo) el iPhone 7 plus que es el que yo heredé de mi hijo David 😉

Captura 3. Aquí falta la referencia a Xamarin.Forms (y no se muestra el dispositivo físico)

Captura 4. Con la referencia a Xamarin.Forms sí muestra los dispositivos físicos.

Y esto es todo… ya sabes… espero que te sea de utilidad (y espero que a mí me vuelva a serlo cuando me pase de nuevo… jejejeje, que conociéndome, seguro que me vuelve a pasar).

Nos vemos.
Guillermo

.NET MAUI aún está muy verde (comparado con Xamarin.Forms)

Pues eso… por fin he logrado hacer algo medianamente útil con .NET MAUI y Visual Studio 2022 (acceso a datos, para ser más concreto) y… pues que en la aplicación de Windows (UWP) funciona bien, pero en la de Android ni de coña… Y ya con la de iOS ni te digo… es que ni siquiera compila… en fin…

La de Android se inicia, pero cuando digo de acceder a una base de datos, da error.

Seguramente será por el «idioma» (codificación). Ya que en las aplicaciones de Xamarin.Forms para que pueda acceder a las bases de datos de SQL Server le tengo que decir (a iOS también) que use la codificación WEST y entonces si funciona (ver la captura 1), pero no tengo ni repajolera idea de cómo hacerlo en .NET MAUI. 🙁

Captura 1. La opción en Xamarin.Forms para indicar que use la codificación oeste (west)
Captura 1. La opción en Xamarin.Forms para indicar que use la codificación oeste (west)

De todas formas, aunque funcione en Windows (me vale para las pruebas), hay cosas tan simples como que un Entry (el típico TextBox de .NET Framework, o casi) no permita que se cambie el contenido… Bueno, permitir, lo permite, pero como si le echaras un vaso de agua al mar para que aumente de nivel… Es decir, que no vale pa ná

En fin… y el día 8 de noviembre quieren lanzar el Visual Studio 2022… ¡que lo lancen! pero bien lejos… porque falla más que una escopetilla de plomos…

Eso sí, uno le dice a esta gente que fallos va encontrando, pero… ¡a ellos no les falla!… jajajaja me rio yo solo… por no llorar…

De hecho, con un bug «tonto» de seleccionar código con las teclas ALT+SHIFT (suelo hacerlo bastante cuando quiero copiar el código para colorearlo y publicarlo en este blog, por ejemplo).

Pues no hay forma de que esta gente sigan los mismos pasos que ya les he indicado varias veces, ellos lo hacen a su manera, y de esa forma no falla… pero no es lo mismo. Ya que, si yo quiero seleccionar algo que está indentado, en Visual Studio 2022 falla, sin embargo, en Visual Studio 2019 va bien.

Si tienes curiosidad, puede ver el «feedback» que yo lo titulé (en inglés para que no se pierdan mucho): BUG: Selecting block of text with SHIFT+ALT (+ Down, Left keys) moves the selection start down (not always).

Y algunos más… que, hasta pueden resultar graciosos, como el que al seleccionar el texto de esta forma se quedan varios cursores y si escribes algo se pone ese texto en todos los cursores que haya (uno por cada línea seleccionada).

Este es el enlace (y el título): BUG VS2022: Selecting with ALT+SHIFT, releasing the selection, the blue and red cursor remains and if you type the text typed is set in several places.

Bueno… no te canso más… aunque, si vives por estos lares… esta noche podrás dormir una hora más… que nos cambian el horario de verano al de invierno y… a las 3 de la madrugada serán las 2… 😉

Buenas noches.

Nos vemos.
Guillermo

Por fin se podrán ver los artículos / posts de elguillemola.com desde elguille.info

Pues eso, que desde que cambié el alojamiento de «mi sitio», elguille.info, de Axarnet/Domitienda a acens (de telefónica) los enlaces que tenía «incrustados» en las páginas (para que mostrase en una página de mi sitio el artículo de mi blog (este) no se mostraban a causa de un error que mostraba este texto:
The request was aborted: Could not create SSL/TLS secure channel
La solución ha sido fácil (después de haber buscado en la red sobre este error) y que he he econtrado en StackOverflow, concretamente en un comentario a una de las respuestas, no puedo poner el enlace a ese comentario, pero es el que tiene este texto:
You don’t need to exclusively set it to a single type, you can simply append as well. System.Net.ServicePointManager.SecurityProtocol |= System.Net.SecurityProtocolType.Tls12;
– Nae Mar 20 ’18 at 8:44

Ese código es para C#, en Visual Basic sería este:



System.Net.ServicePointManager.SecurityProtocol = 
            System.Net.ServicePointManager.SecurityProtocol Or
               System.Net.SecurityProtocolType.Tls12



Lo que tengo que hacer ahora es ver si ese código simplemente lo puedo poner en la página maestra o tendré que ponerlo en cada página… creo que si se ejecuta una sola vez es suficiente, así que… si ves que da nuevamente ese error, te ruego que me lo digas. Gracias.

Nos vemos.
Guillermo