Archivo de la etiqueta: Visual Basic

Ahora entiendo mejor porqué ya no quieren seguir actualizando/avanzando Visual Basic

Pues eso… viendo las novedades de C# 10.0 me he topado con los detalles de la «novedad» Global using directives, dicho de esa forma parece algo «WOW!», y… es algo que siempre he querido que quitasen de forma predeterminada al crear un nuevo proyecto de Visual Basic para .NET: que haya importaciones implícitas de espacios de nombres al crear un nuevo proyecto.

Y eso es lo que es esa «nueva» característica de C# 10.0, crear definiciones «using» (ya que «Imports» es cosa de Visual Basic para .NET) de los espacios de nombres más habituales según el tipo de proyecto creado.

Que sí, que está muy bien, pero a mí nunca me ha gustado, de hecho, en la mayoría de los proyectos que creaba (sobre todo si era para compartirlo como parte de algún artículo), lo quitaba, con idea de así tener que escribir las importaciones de espacios de nombres en cada fichero (de código) de ese proyecto. Porque es la única forma de saber «a ciencia cierta» qué espacios de nombres se estaban usando en ese fichero de código.

Para que nos entendamos, a diferencia de C#, en Visual Basic el espacio de nombres System.Text nunca se importa de forma predeterminada, algo que sí ocurre en los proyectos de C#; por tanto, si quiero crear un nuevo objeto del tipo StringBuilder, o bien lo creo usando el nombre «completo» de la clase StringBuilder: System.Text.StringBuilder o bien declaro la importación del espacio de nombres System.Text y ya el compilador sabrá que StringBuilder está accesible (al revisar las clases contenidas en cada uno de los espacios de nombres que estén incluidos en las importaciones).

¡Eh! que no es una crítica, que me parece muy bien, y si ahora los del TEAM de C# lo están añadiendo como algo «predeterminado» será porque tampoco será tan malo, lo único que digo es que sigue siendo lo mismo que teníamos los «desarrollado-res» de Visual Basic desde hace ya casi 20 años… ¡NOVEDAD! WOW! 😉

Total, a lo que iba, que ya no hace falta seguir dando nuevas características a Visual Basic, porque al final C# será como era Visual Basic hace 20 años… eso sí, con (entre otras cosas) acabando la línea con un punto y coma.

Pero preferiría que Visual Basic evolucionara con las «nuevas características» realmente nuevas, para que a los que no nos gusta usar punto y coma para indicar que una instrucción ha finalizado o poner cosas entre llaves, etc., etc., y dejar de ver cómo C# evoluciona para hacer cosas que desde «siempre» ha hecho Visual Basic y, casi seguro, que era criticado por eso… Y si no me crees, échale un vistazo a las declaraciones sin tipos de variables (que, siempre al estilo de C#) en C# también lo añadieron en su día como novedad novedosa…

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

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)

Charla con Héctor de León: ¿Está Comenzando a Morir Visual Basic?

Pues eso… ayer día 30 de agosto estuve charlando con Héctor de León (del canal de YouTube hdeleon.net) y ya está publicada y aquí te dejo el enlace.

¿Está Comenzando a Morir Visual Basic? | Invitado: Guillermo Som del elguillemola.com

 

Espero que te resulte interesante.

 

Nos vemos.
Guillermo

Detectar por código C# o Visual Basic si una página ASP.NET se muestra en un móvil

Pues eso… aunque he leído por ahí que no es conveniente detectar si se está navegando en un dispositivo móvil… eso era porque lo hacía con código duro (hard-code) es decir, detectar según el valor devuelto por userAgent de window.navigator, que sí, que puede producir resultados no deseados… pero… si usas Request.Browser.IsMobileDevice la cosa cambia.

Y hacer esa comprobación es bien simple.
¿Dónde hacerla?
En cualquier parte del código «script» de tu página ASP.NET (de .NET Framework), ya sea que estés usando Visual Basic o C# (o incluso otros lenguajes que soporten las páginas web asp.net de .net framework).

Un par de ejemplos, por favor

Esta es una página .aspx con código para C#:

<%@ Page Language="C#" AutoEventWireup="true" %>

<script runat="server">
    protected void Page_Load(object sender, EventArgs e)
    {
        if (Request.Browser.IsMobileDevice)
        {
            LabelDesktop.Visible = false;
            LabelMobile.Visible = true;
        }
        else
        {
            LabelDesktop.Visible = true;
            LabelMobile.Visible = false;
        }
    }
</script>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body style="font-family:Consolas">
    <form id="form1" runat="server">
        <div>
            <asp:Label runat="server" ID="LabelMobile"  Visible="false"
                Font-Size="xx-Large" Font-Bold="true"
                Text="Estas viendo esto en el navegador de un dispositivo móvil." />
            <asp:Label runat="server" ID="LabelDesktop"  Visible="false"
                Font-Size="xx-Large" Font-Bold="true"
                Text="Estas viendo esto en el navegador de escritorio." />
        </div>
    </form>
</body>
</html>

Esta es una página .aspx con código para Visual Basic:

<%@ Page Language="VB" AutoEventWireup="true"  %>

<script runat="server">
    Protected Sub Page_Load(sender As Object, e As EventArgs)
        If Request.Browser.IsMobileDevice Then
            LabelDesktop.Visible = False
            LabelMobile.Visible = True
        Else
            LabelDesktop.Visible = True
            LabelMobile.Visible = False
        End If
    End Sub
</script>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body style="font-family:Consolas">
    <form id="form1" runat="server">
        <div>
            <asp:Label runat="server" ID="LabelMobile"  Visible="false"
                Font-Size="xx-Large" Font-Bold="true"
                Text="Estas viendo esto en el navegador de un dispositivo móvil." />
            <asp:Label runat="server" ID="LabelDesktop"  Visible="false"
                Font-Size="xx-Large" Font-Bold="true"
                Text="Estas viendo esto en el navegador de escritorio." />
        </div>
    </form>
</body>
</html>

Nota:
Puedes tener las dos páginas en una misma aplicación o proyecto WEB de Visual Studio sin necesidad de hacer nada especial, solo tener las páginas en un sitio que acepte .NET Framework.

A tener en cuenta

Si muestras la páginas en un dispositivo móvil, es posible que el navegador te permita ver la página como «escritorio», en ese caso, el valor que devuelve es escritorio, no que es móvil.
En las siguientes capturas tienes la demostración.
En esas capturas estoy usando el Edge para Android en un Google Pixel 4a.

En la figura 1 estoy mostrando la página versión de Visual Basic en el móvil, que si quieres la puedes probar usando el enlace mostrado (está alojada en mi sitio: elguille.info/WebFormVB.aspx).

Figura 1.

 

En la figura 2 te muestro la versión para C# antes de cambiarla a modo escritorio.
También puedes probarla usando este enlace en mi sitio: elguille.info/WebFormCS.aspx.

Figura 2. Mostrando la página como móvil y queriendo cambiar a versión para ordenador

 

Figura 3. Mostrando la página como si estuviese en escritorio y queriendo cambiar a versión apra sitio móvil.

 

Nota:
También puedes probarlo en el navegador de escritorio usando las herramientas de desarrollador, que en Edge y Chrome se pueden acceder usando Ctrl+Shift+I.
Y desde esas herramientas puedes indicar que se muestre como si fuese en un móvil (ver la figura 4).

Figura 4. Usando las herramientas de desarrollador puedes ver en el escritorio cómo sería usarlo en un móvil… o casi.

Espero que te sea de utilidad 😉

Nos vemos.
Guillermo

Charlas (podcasts) con Luis del Valle Hernández de ProgramarFacil

Pues eso… esto es de hace unos años, del 4 de junio de 2015 concretamente (según me ha dicho Luis, porque yo ya no lo recordaba), y aunque la entrevista/charla se hizo de una vez, él las publicó (en modo podcast, audio) en dos partes.

Pero como las he buscado y no las he encontrado ni en mi sitio (elguille.info) ni en este blog, lo publico ahora aunque sea después de tanto tiempo ya que considero que deben estar «localizables» porque fueron las primeras :-).
Así podrás saber más cosas sobre mí… aunque a fecha de hoy ya hay 4 charlas en YouTube, es conveniente que estos dos podcasts también estén visibles al buscar las charlas o entrevistas que me han hecho.

Así que… aquí tienes los enlaces a estos dos podcasts con la entrevista de Luis del Valle Hernández que me hizo el 4 de junio de 2015:

Charla 1: Primera parte de la charla con El Guille programación .NET

Charla 2: Segunda parte de la charla con El Guille programación .NET

 

Y ya que estamos con los enlaces, te pongo también los 4 de YouTube que me han hecho entre junio de 2020 y abril de 2021 (en plena pandemia del COVID-19):

1- Entrevista a Guillermo Som (elGuille) por Sergio Alejandro Campos para el canal EXCELeINFO (16-jun-2020)

2- Pablo Tilotta entrevista a ElGuille (21-jul-2020)

3- La evolución de .Net, una plática de Héctor de León con «El Guille» (17-nov-2020)

4- SevillaDotNet: Café Virtual con ‘ElGuille’ (07-abr-2021)

 

Nos vemos.
Guillermo

Acompáñame en el café virtual con Marcelo este miércoles 7 de abril

Pues eso… Marcelo de SevillaDotNet me ha invitado a un café virtual el próximo miércoles día 7 de abril a las 18:30 hora de la España peninsular (una hora menos en Canarias), así que… si nos quieres acompañar regístrate y asiste siguiendo este enlace: Café Virtual con Guillermo Som.

Nota del martes 6 de abril
Si quieres, también puedes verlo en directo por YouTube o bien usar este mismo enlace para después de mañana 7 de abril de 2021:

SevillaDotNet: Café Virtual con ‘ElGuille’

 

 

Si quieres ver qué hora es ahora en España (Madrid) sigue el enlace y así sabrás qué hora será en tu país 😉
Me comentan que al pulsar el enlace te muestra la hora en tu ciudad.

Este es el resumen de la charla cafetera 🙂

En este café virtual vamos a charlar con Guillermo Som. Tras tantos años participando y ayudándonos a todos con su sitio elguille.info, probablemente te haya ayudado en algún momento.
Vamos a charlar sobre sus inicios en la informática, sobre el camino que él ha tenido cómo programador, de .NET y su evolución y mucho más.

¿Te unes a nosotros?

¡Te espero!

Nos vemos.
Guillermo

Mejorar el rendimiento al usar GetExecutingAssembly

Pues eso… ya te lo comenté hace unos meses, aunque estaba escondido en las novedades de gsNotasNET.Android v2.0.0.33, y era porque me daba error (sin avisar, para más señas) a la hora de usar la forma recomendada de usar Assembly.GetExecutingAssembly.

En esa ocasión me daba error la aplicación de Xamarin.Forms y sin saber porqué… Pero la he vuelto a probar y por ahora, al menos en el IDE de Visual Studio 2019 va bien.
De todas formas, ya sabes si usas lo que te voy a explicar aquí, y ves que la aplicación casca, ya sabes porqué es.

La documentación (en inglés) dice esto:

For performance reasons, you should call this method only when you do not know at design time what assembly is currently executing. The recommended way to retrieve an Assembly object that represents the current assembly is to use the Type.Assembly property of a type found in the assembly.

Que en el idioma actualizado de Cervantes viene a decir esto (según Google Translator):

Por motivos de rendimiento, debe llamar a este método solo cuando no sepa en tiempo de diseño qué ensamblado se está ejecutando actualmente. La forma recomendada de recuperar un objeto Ensamblado que representa el ensamblado actual es usar la propiedad Type.Assembly de un tipo que se encuentra en el ensamblado.

Aquí te voy a poner el código (tanto de Visual Basic como de C#) para usar esta forma recomendada de asignar un ensamblado (de la clase System.Reflection.Assembly).

Este código está en bibliotecas (proyectos del tipo Class Library) para usar con .NET Standard 2.0 (de esta forma los ensamblados se podrán usar tanto en .NET Core como en .NET Framework).

Ejemplo para C#

public static string VersionDLL()
{
    var ensamblado = typeof(AboutViewModel).Assembly;
    var fvi = FileVersionInfo.GetVersionInfo(ensamblado.Location);
    // FileDescription en realidad muestra (o eso parece) lo mismo de ProductName
    var s = $"{fvi.ProductName} v{fvi.ProductVersion} ({fvi.FileVersion})" + 
        $"\r\n{fvi.Comments}";

    return s;
}

Ejemplo para Visual Basic

Public Function VersionDLL() As String
    Dim ensamblado = GetType(DatosMostrar).Assembly
    Dim fvi = FileVersionInfo.GetVersionInfo(ensamblado.Location)
    ' FileDescription en realidad muestra (o eso parece) lo mismo de ProductName
    Dim s = $"{fvi.ProductName} v{fvi.ProductVersion} ({fvi.FileVersion})" &
        $"{vbCrLf}{fvi.Comments}"

    Return s
End Function

Ese código mostrará la versión del ensamblado, la versión del fichero y la descripción, aunque en realidad a la propiedad a la que tienes que acceder es a Comments, ya que FileDesciption muestra lo mismo que ProductName.

Y aquí tienes una captura para la aplicación de Android con los comentarios de las 3 bibliotecas que estoy usando, 2 de ellas escritas con Visual Basic y la tercera (la que le da funcionalidad visual a la aplicación está escrita en C#).

Figura 1. Captura en el emulador de Android.
Figura 1. Captura en el emulador de Android.

Y esta otra captura es de la aplicación en el emulador (local) de UWP (Universal Windows Platform) pero con la aplicación real. Aunque en modo depuración.

Figura 2. Captura en el (emulador) de UWP.
Figura 2. Captura en el (emulador) de UWP.

Espero que te sea de utilidad… Esa es siempre la idea…

Nos vemos.
Guillermo

P.S.
El puñetero Jetpack agrega código (de más) a las imágenes y cuando estas se muestran desde www.elguille.info, simplemente no se ven… pero… puedes pulsar en el sitio (en blanco) en el que está la imagen y te la mostrará…
Lo mismo quito el Jetpack, que, aparte del «bloque» Markdown y el poder publicar en twitter y mi sitio de facebook, no me sirve de mucho…

Respuesta de Microsoft a la petición de seguir añadiendo características a Visual Basic

Esto es solo para que aparezca en las entradas recientes.

El comentario de hoy 8 de marzo de 2021 está en este enlace.

Por cierto, la petición ya no se puede votar, porque la han cerrado, pero se pueden añadir comentarios… 😉

#evolveVB #evolucionarVB

Nos vemos.
Guillermo

Nuevas ‘versiones’ de Visual Studio 2019

Pues eso… con fecha de anteayer 2 de marzo, hay nuevas versiones de Visual Studio 2019, tanto para la versión final: v16.9.0 como para la preview: v16.10 Preview 1.0.

Este es un extracto de las novedades de .NET Productivity de la versión 16.9.0:
He resaltado las que, a mí me, parecen más interesantes.

.NET Productivity (versión final v16.9.0)

  • There is now IntelliSense completion for preprocessor symbols.
  • Solution Explorer now displays the new .NET 5.0 Source Generators.
  • Go To All won’t display duplicate results across netcoreapp3.1 and netcoreapp2.0.
  • Quick Info now displays compiler warning IDs or numbers for suppressions.
  • Using directives will now automatically get added when copying and pasting types to a new file.
  • IntelliSense completion will now automatically insert a semicolon as a commit character for object creation and method completion.
  • Semantic colorization for C# 9.0 records.
  • Refactoring that removes unnecessary discards.
  • Refactoring that converts a verbatim and regular string to an interpolated string preserving curly braces that were intended to go in the output.
  • Code fix in Visual Basic that removes the shared keyword when you convert methods that are shared to a module.
  • A refactoring that suggests using new(…) in non-contentious scenarios
  • A code fix that removes redundant equality expressions for both C# and Visual Basic
  • The .NET Code Style (IDE) analyzers can now be enforced on build
  • The Syntax Visualizer shows the current foreground color for enhanced colors
  • A new tooltip when hovering over the diagnostic ID for pragma warnings
  • When you type the return key from within a comment the new line is now automatically commented out
  • Inline parameter name hints enhancements
  • .NET Core Debugging with WSL 2

Para la versión preview… pues… mejor lo miras en la página de información publicada por la gente de Microsoft.

Nos vemos.
Guillermo