Archivo de la etiqueta: truco

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

Crear acceso directo a una máquina virtual (para no tener que abrirla desde el Hyper-V Manager)

Pues eso… que estoy usando algunas máquinas virtuales de Hyper-V para los canales de Windows Insider, una de ellas con la del canal Dev (más inestable) y otra con el canal Beta (algo más estable) y cada vez que enciendo el equipo (o lo reinicio tras una actualización) tengo que abrir el Hyper-V Manager para poder acceder a esas máquinas virtuales.

Pensando (algunas veces me da por pensar estas cosas) que lo más simple sería poder tener un acceso directo y abrir las máquinas sin tener que usar el administrador de Hyper-V, así que… buscando en la red me encontré que es fácil hacerlo… pero como suelo darle nombres (con espacios) a esas máquinas virtuales, en esos ejemplos no aclaraban cómo hacerlo, así que… me he decido a publicar esto para que quede constancia de cómo hacerlo (ya sabes, después de un tiempo puede que se me olvide y así podré encontrarlo al hacer una búsqueda en la red de redes 😉 )

Y de paso, te lo explico por si quieres hacerlo.

Primero lo primero

Lo primero a tener en cuenta es cómo crear ese acceso directo.

Para crear un acceso directo lo puedes hacer de dos formas.

La primera: Te posicionas en el directorio donde quieres crear ese acceso directo, por ejemplo, en el escritorio (que es la opción más rápida si quieres evitar tener que abrir esa carpeta con el acceso directo), pulsas en el botón secundario y de las opciones mostradas (ver captura 1 que es de Windows 11, pero en las versiones anteriores de Windows será algo parecido, pero con otro look) es elegir Nuevo > Acceso directo (New > Shortcut).

Captura 1. Crear un acceso directo en Windows 11.

A continuación, escribe el path del administrador de Hyper-V, que es el siguiente:
C:\Windows\System32\vmconnect.exe (ver captura 2).

Captura 2. Indicar el path de vmconnect.exe

Tip:
No lo busques en la carpeta de Archivo de Programas > Hyper-V, que ahí no está, ya que suele estar en C:\Windows\System32.

Pulsa en Siguiente (Next) y si quieres le cambias el nombre del nuevo acceso directo y finalmente pulsas en Finalizar (Fisnish) (ver captura 3).

Captura 3. Indicar el nombre del acceso directo

La segunda: Abre la ubicación de vmconnect.exe (que tal como te he indicado antes está en C:\Windows \System32, si en lugar de C usas otro nombre de unidad como arranque, indica ese nombre de unidad).

Busca el fichero vmconnect.exe y pulsa sobre la aplicación con en el botón secundario (el derecho para diestros, el izquierdo para zurdos) y selecciona crear acceso directo (como no podrás crearlo en la ubicación del programa, te preguntará si quieres crearlo en el escritorio).

El acceso directo estará en el escritorio.

Una vez creado el acceso directo a vmconnect.exe

Selecciona el acceso directo y pulsa con el botón secundario para elegir propiedades.

Después de la ubicación de vmconnect.exe indica el nombre del servidor de Hyper-V seguido del nombre de la máquina virtual.

En mi caso, sería GUILLE-JUL1421 «Windows 11Pro Dev» (ver captura 4).

Fíjate en las comillas dobles para el nombre de la máquina virtual, esto es así porque contiene espacios. Si el nombre de la máquina virtual no tiene espacios no es necesario ponerlo dentro de comillas dobles.

Captura 4. Usar comillas dobles si alguno de los parámetros tienen espacios

 

Dale permisos de administrador al acceso directo

Es necesario que le des acceso de administrador al acceso directo.

Para ello, en las propiedades del acceso directo, pulsa en el botón Avanzado (Advanced) y marca la casilla de Ejecutar como administrador (Run as administrator) (ver la captura 5), y acepta hasta cerrar la ventana de propiedades.

Captura 5. Indicar que el acceso directo se ejecute como administrador

Para saber con seguridad cómo se llama el servidor de Hyper-V y la máquina virtual, puedes verlo abriendo el administrador de Hyper-V (Hyper-V Manager) y así estar seguro (ver captura 6).

Captura 5. El administrador de Hyper-V

 

Nota:
En algunas ocasiones, al abrir los 2 accesos directos que suelo utilizar, en Windows 11, me los muestra en la barra de tareas como 2 iconos (ver captura 7) y otras veces como un solo icono, mostrando las dos opciones al pasar el ratón sobre él (ver captura 8).
En las versiones anteriores de Windows te los mostrará según tengas configurada la barra de tareas para mostrar los iconos relacionados con una misma aplicación.

Si abres las 2 máquinas virtuales desde el administrador de Hyper-V siempre te los mostrará como un solo icono.

Captura 7. En Windows 11 algunas veces (usando los accesos directos) los muestra como 2 iconos separados

 

Captura 8. La forma habitual de mostrar los iconos de un mismo tipo de aplicación en Windows 11

 

Y esto es todo… espero que te sea de utilidad… y si así ha sido (o no), no te olvides de invitarme a un «refresco virtual» 😉
(pulsando en el botón donar de PayPal).
Gracias.

Nos vemos.
Guillermo

Configurar una máquina virtual de Hyper-V para usar el Dev Channel de Windows Insider con Windows 11

Pues eso… que quería usa el Dev Channel de Windows Insider para tener la versión más reciente (aunque posiblemente más inestable) de Windows 11 y no me dejaba, solo me permitía los canales Beta y Release Preview. Y mire en la configuración de Hyper-V y… ¡ahí estaba la solución!

Y no es más que activar las opciones de Enable Trusted Platform Module (TPM) en la «pestaña» Security (ver la figura 1).

Figura 1. Configuración de una máquina virtual de Hyper-V para habilitar TPM.

No sé si será Es necesario marcar también la opción Encrypt state and virtual machine migration traffic, pero «for if las flais» también la he marcado (seleccionado), además de indicarle que utilice 2 procesadores virtuales (en la «pestaña» Processor).

Y con esos cambios ya me deja seleccionar (y que funcione) el canal «DEV» de Windows Insider Program.

Nota del 13-dic-21 01:57:
De todo lo dicho, además agrego que, con las pruebas hechas, si ponía 5120MB de RAM (5GB) no me lo daba por bueno… Con 6000MB (6GB) si lo da por bueno, ver la figura 2.
Y eso que dice que «al menos tiene 4GB de RAM», en fin…)

Figura 2. Con 6000MB (6GB) si lo da por bueno, con 5GB no me lo da por «compatible» para Windows 11.

Espero que te sea de utilidad… ¡esa es siempre la intención! 😉

Nos vemos.
Guillermo

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

Sugerencias de palabras mientras escribes (Windows 11)

Pues eso… que en Windows 11 hay una opción de que te muestre sugerencias mientras escribes texto (ver captura 1).

 

Captura 1. Sugerencias mientras escribes.

 

Nota:
Como puedes ver en la captura 1, las sugerencias son en los idiomas que tengas instalados/configurados.

Para activarla o desactivarla entra en configuración y selecciona del panel izquierdo: Time & Language (captura 2).

 

Captura 2. En Time & language está Typing.

 

Pulsa en Typing y te mostrará las opciones disponibles (ver captura 3).

 

Captura 3. En Typing selecciona la primera opción para activar o desactivar.

 

La que activa o desactiva las sugerencias es: Show text suggestions when typing on the physical keyboard, evidentemente solo al usar el teclado físico (no el virtual).

La otra opción es Multilingual text suggestions que sirve para que te muestre las sugerencias en los idiomas que tengas instalado (y que soporten esta característica), por supuesto esa opción no tiene efecto si la anterior no está activada.

 

Y esto es todo por ahora… 😉

 

Nos vemos.
Guillermo

Indicar qué idioma usar en las aplicaciones en Windows 11

Pues eso… he instalado el Windows 11 en mi equipo «de trabajo» y como el Windows 10 que tenía era en español-España, así lo he tenido que dejar al instalar el Windows 11. Pero, aunque lo tenía en español, yo suelo usar el sistema operativo en inglés (costumbres), y seguramente le añadiría al Windows 10 el pack del idioma inglés (United States), pero claro… las cosas se me olvidan (y últimamente más, y no es tema de la edad, te lo puedo asegurar… no es por justificarme, ya que a la hora de escribir esto ya tengo los 64 cumplidos), total… que a mí me gustan usar los «shorcuts o teclas rápidas» en versión inglesa, es decir CTRL+S para guardar, CTRL+B para poner en negrita o el CTRL+A para seleccionar todo, por tanto, suelo tener las aplicaciones en inglés, y así tenía el OneNote para Windows 10 o el simple Notepad.

Nota:
En otras aplicaciones que el idioma es seleccionable, suelo usar el inglés también, pero en esas aplicaciones no les afecta el idioma del sistema (o casi).

Y ahora, al reinstalar el Windows 11, esas aplicaciones me salían en español, que no es el problema, pero sí lo es esos «atajos de teclas».

Después de varias vueltas, me di cuenta de que el idioma usado en las aplicaciones es el que se indique primero en la lista de idiomas, que está en la configuración: Time & language > Language & region (ver captura 1).

 

Captura 1. La configuración de Hora e idioma.

 

 

Y esto es todo… es por si me pasa de nuevo o por si te pasa 😉

 

Nos vemos.
Guillermo

Solución si actualizas a Windows 11 y no te muestra los iconos de la barra de tareas

Pues eso… pero el título completo debería ser: Solución si actualizas a Windows 11 desde Windows Insider Program y no te muestra los iconos de la barra de tareas y/o al pulsar en un icono del escritorio o un ejecutable desde una carpeta te da error o al pulsar en un icono de una carpeta o al pulsar combinaciones de teclas Windows, después de tomarse su tiempo va apareciendo poco a poco.

El truco lo he sacado de uno de los muchos posts sobre incidencias con las actualizaciones de Windows, particularmente una de las respuestas de uno de ellos:

https://techcommunity.microsoft.com/t5/report-an-issue/windows-11-problems/m-p/2714976/highlight/true#M2032

Los pasos que yo he seguido para poder poner en marcha el Windows 11 en mi laptop (portátil) el cual me decía (y sigue diciendo) que no es compatible para Windows 11, son estos: (están en inglés porque lo he puesto como respuesta a un feedback de Windows Insider Program que creé al pasarme eso que te he comentado al principio).

I used these «modifies steps» because I can’t show up the cmd window to type the full text to change the registry and reboot the PC

1: Use CTRL-ALT-DEL and choose to open Task Manager.
2: Choose “More details” at the bottom of Task Manager to expand Task Manager.
3: Go to “File” and choose “Run new task”.
4: Type in the “Open” field:
reg delete HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\IrisService /f
Then press the RETURN key.
5: Then restar the computer (You can use again CTRL-ALT-DEL and select Restart from the Power button on the right bottom side of the screen.
After rebooting, everything should be back to normal.

Esta es la traducción de Google:

Usé estos «pasos de modificación» porque no puedo mostrar la ventana de cmd para escribir el texto completo para cambiar el registro y reiniciar la PC

1: Use CTRL-ALT-DEL y elija abrir el Administrador de tareas.
2: Elija «Más detalles» en la parte inferior del Administrador de tareas para expandir el Administrador de tareas.
3: Vaya a «Archivo» y elija «Ejecutar nueva tarea».
4: Escriba en el campo «Abrir»:
reg delete HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\IrisService /f
Luego presione la tecla RETURN.
5: Luego reinicie la computadora (puede usar nuevamente CTRL-ALT-DEL y seleccionar Reiniciar desde el botón de Encendido en la parte inferior derecha de la pantalla.

Después de reiniciar, todo debería volver a la normalidad.

En las siguientes capturas puedes ver cómo tenía el escritorio antes de actualizar de Windows 10 Pro a Windows 11 Pro OS Build: 22000.176.

Figura 1. El Windows 10 antes de reiniciar para instalar el Windows 11

 

Figura 2. El Windows 11 con los problemas de no mostrar los iconos del taskbar, etc.

 

Figura 3. Después de aplicar el truco explicado.

 

Si te fijas en las figuras 1 y 3, me indica que ese equipo no es compatible con Windows 11, pero después de haber cambiado al canal Beta de Windows Insider Program ya si pude instalarlo, creo recordar que hace unos meses no podía seleccionar esa opción, ni la de Dev tampoco, esta última es para instalar versiones menos estables, ya que la que se instala con la opción Beta Channel es la más parecida a la que saldrá el próximo día 5 de octubre.

Y esto es todo… espero que re pueda ser de utilidad.

Nos vemos.
Guillermo

P.S. 03-sep-21 20:43:
Hoy he recibido de la gente de Windows Insider Programa la respuesta a lo que ya indiqué, con los pasos oficiales, que son los que compartió el que hizo el comentario que mencioné y que está en este enlace: El workaround oficial sobre este error.

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

Obtener las IPs (IPv4 e IPv6) del usuario y mostrar solo las IPv4 usando .NET (Core) [Código para Visual Basic y C#]

Pues eso… aquí tienes un ejemplo que son 2 (o cuatro si tenemos en cuenta que el código que te voy a mostrar es tanto para Visual Basic como para C#/CSharp) y es para obtener las IPs del usuario (o donde se ejecute el código) y de esas IPs (que contendrá las IPv6 y las IPv4) extraer solo las IPv4.

Este código utiliza expresiones regulares (RegEx) y por tanto necesitas añadir una importación del espacio de nombres System.Text.RegularExpressions, también utiliza métodos para acceder al nombre del equipo (host name) y obtener las direcciones IP, por tanto, necesitarás una importación al espacio de nombres System.Net.

Este código sirve tanto para aplicaciones de escritorio (los ejemplos están hechos para aplicaciones de consola para todas las plataformas), aplicaciones móviles y aplicaciones WEB.

Yo lo he probado en las dos primeras, y cuando lo haga en la tercera, te mostraré el código usado (o lo pondré en el repositorio de GitHub que crearé para poner el código de ejemplo) y las cosas que debas tener en cuenta, siempre y cuando tengas algo que tener en cuenta 😉

Nota 01-sep-2021:
Ya he publicado una página ASPX (asp-net) para probar el código.
Para esa página he creado una DLL con idea de ponerla en el directorio BIN del hosting donde tengo alojado «mi sitio» www.elguille.info.
En GitHub también está el código de esa DLL (del proyecto, que en este caso lo he creado con VB).
Este es el enlace de la página de prueba: ComoNET: Utils IP (.NET Core) (elguille.info)

Nota:
Las dos funciones principales: la que obtiene las IPs y la otra que extrae las IPv4 de esas IPs están en una clase estática (compartida sería en VB, pero en este caso no es necesario indicar Shared) con métodos estáticos (así debe ser en C#), esos métodos en Visual Basic están declarados con Shared, mientras que en C# se utiliza static.

En realidad, en Visual Basic podría haber usado un módulo (Module) en vez de una clase y definir expresamente los métodos de forma compartida, pero la diferencia de declarar los métodos como compartidos en una clase y usar esos métodos desde un módulo es que «tras las bambalinas» hay más código si se define un módulo. Me refiero al código IL generado, aunque en realidad solo hay más código en el constructor del módulo, ya que el código IL de los métodos es el mismo en ambos casos.
Después te pongo algo sobre esto (seguramente en otro post).

Otro detalle es que en la medida de lo posible he usado declaraciones de variables explícitas en lugar de usar inferencia de tipos, para que así te resulte más fácil ver (o saber) de qué tipo de datos estoy hablando (o utilizando).

Obtener las direcciones IP del usuario actual

En esta primera parte del ejemplo, echaremos mano de los métodos GetHostName y GetHostAddresses de la clase Dns definida en System.Net.

El nombre del host es necesario para saber las IPs, ya que GetHostAddresses utiliza el nombre del host (¿anfitrión?), pero mejor ve el código y después ya veremos si hay algo que aclarar.

Empiezo con el de C# y después te muestro el de Visual Basic.

public static string ObtenerIPs()
{
    StringBuilder sb = new StringBuilder();
    string ipAddresses;

    try
    {
        var hostName = Dns.GetHostName();
        IPAddress[] addresses = Dns.GetHostAddresses(hostName);

        foreach (IPAddress address in addresses)
            sb.Append($"{address}, ");

        ipAddresses = sb.ToString().TrimEnd(", ".ToCharArray());
    }
    catch (Exception ex)
    {
        ipAddresses = "ERROR: " + ex.Message;
    }
    return ipAddresses;
}

 

Public Shared Function ObtenerIPs()

    Dim sb As New StringBuilder()
    Dim ipAddresses As String

    Try
        Dim hostName = Dns.GetHostName()
        Dim addresses As IPAddress() = Dns.GetHostAddresses(hostName)

        For Each address As IPAddress In addresses
            sb.Append($"{address}, ")
        Next

        ipAddresses = sb.ToString().TrimEnd(", ".ToCharArray())
    Catch ex As Exception
        ipAddresses = "ERROR: " & ex.Message
    End Try
    Return ipAddresses
End Function

 

Un par de cosas (tips) a destacar de ese código:
1- La variable addresses es un array del tipo IPAddress, para obtener cada una de las direcciones IP utilizo un bucle foreach (For Each) y las agrego al StringBuilder (por aquello de que consume menos recursos que si las concateno).
2- Como le voy añadiendo a cada IP una coma y un espacio al final (para separarlas), es necesario quitar esa coma del final, para ello utilizo TrimEnd() indicándole qué caracteres quiero quitar del final. Los caracteres indicados al método de la familia Trim deben ser caracteres, no una cadena, por eso utilizo una cadena con los caracteres a quitar del final y la convierto en array de tipo Char con ToCharArray.

Extraer las IPv4 de una cadena con otras cosas usando expresiones regulares

En el método que se encarga de hacer eso, utilizo la clase RegEx para mediante una cadena con «expresiones regulares» (que resultan ser buenas y no regulares 😉 ) y los casos en que ha tenido éxito, los voy agregando a un StringBuilder que después usaré (tras quitar lo que no haya que usar) para devolver como resultado de las direcciones IPv4 de esa cadena entrante.

El código regex para obtener las IPv4 lo he adaptado de un ejemplo del sitio programador clic: Expresión regular de dirección IP.

Aquí tienes el código de ese método para Visual Basic y C#.

Public Shared Function LasIPv4(ipAdresses As String) As String
    Dim sb As New StringBuilder()

    Dim sRegExIPv4 As String = "((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)"
    Dim r As Regex = New Regex(sRegExIPv4)

    For Each m As Match In r.Matches(ipAdresses)
        If m.Success Then
            sb.Append($"{m.Value}, ")
        End If
    Next

    Return sb.ToString().TrimEnd(", ".ToCharArray())
End Function

 

public static string LasIPv4(string ipAdresses)
{
    StringBuilder sb = new();

    string sRegExIPv4 = @"((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)";
    Regex r = new Regex(sRegExIPv4);
    foreach (Match m in r.Matches(ipAdresses))
    {
        if(m.Success)
        {
            sb.Append($"{m.Value}, ");
        }
    }

    return sb.ToString().TrimEnd(", ".ToCharArray());
}

Y esto es todo… ¡Ah! ¡No! que falta el código de cómo usar estos dos métodos.

Cómo usar los métodos anteriores

Eso está en el método Main del «programa» de consola.

Aquí tienes el método Main que los utiliza.

static void Main(string[] args)
{
    //Console.WriteLine("Hello World!");
    Console.WriteLine("Ejemplo en C# usando .NET 5.0 para obtener las IPs y extraer con RegEx solo las IPv4.");
    Console.WriteLine();

    string ipAdresses = Utils.ObtenerIPs();

    Console.WriteLine("La cadena con todas las IPs:");
    Console.WriteLine(ipAdresses);
    string ret = Utils.LasIPv4(ipAdresses);

    Console.WriteLine();
    Console.WriteLine("Direcciones IPv4:");
    Console.WriteLine(ret);

    Console.WriteLine();
    Console.WriteLine("Pulsa INTRO para terminar.");
    Console.ReadLine();
}

 

Sub Main(args As String())
    'Console.WriteLine("Hello World!")
    Console.WriteLine("Ejemplo en Visual Basic usando .NET 5.0 para obtener las IPs y extraer con RegEx solo las IPv4.")
    Console.WriteLine()

    Dim ipAdresses As String = Utils.ObtenerIPs()

    Console.WriteLine("La cadena con todas las IPs:")
    Console.WriteLine(ipAdresses)
    Dim ret As String = Utils.LasIPv4(ipAdresses)

    Console.WriteLine()
    Console.WriteLine("Direcciones IPv4:")
    Console.WriteLine(ret)

    Console.WriteLine()
    Console.WriteLine("Pulsa INTRO para terminar.")
    Console.ReadLine()
End Sub

 

Aquí te dejo una captura del programa en ejecución.

 

Ahora sí, esto ha sido todo amigos… 😉

Nos vemos.
Guillermo

P.S.
Aquí tienes el enlace al repositorio de GitHub con el código de ejemplo completo, tanto para Visual Basic como C# (con sus proyectos respectivos para usar con Visual Studio 2019 o superior, incluso puede que anterior, pero no lo he comprobado).
elGuille-info/Obtener-IP-y-extraer-IPv4: Ejemplo en C# y Visual Basic de cómo obtener las IP (IPv4 e IPv6) y extraer solo las IPv4 (github.com)