Archivo de la etiqueta: evolveVB

Generar las clases (de VB o C#) de una tabla de SQL Server o Access (mdb)

Pues eso… este post es para tener actualizada la utilidad CrearClaseTabla que en su día (allá por 2004) creé para generar o crear clases para acceder a una base de datos de SQL Server o de Access.

La idea de esta utilidad (la aplicación y la DLL que es la que hace el trabajo) es crear clases de Visual Basic o C# de cada tabla de la base de datos, con idea de facilitar el acceso por código a esas tablas.

En la última actualización de hoy 1 de octubre de 2022 se contempla, entre otras cosas, la definición de variables asignadas sin indicar el tipo (inferencia de tipos) además de convertir adecuadamente las conversiones de tipo de Visual Basic a C# (aunque en el código solo uso CInt).

Nota:
He creado el proyecto para .NET 6.0 (Windows) y está disponible en GitHub: gsCrearClasesTablas.
Por ahora el código es el mismo en este nuevo proyecto como en el que referencio en este post/artículo que es para .NET Framework 4.8.1

El código «base» que utilizo es el que yo uso con Visual Basic y la clase CrearClase apoyada de ConvLag se encarga de generar el código de Visual Basic o el de C#.

Por ejemplo, el código que te muestro primero, en el generador de clases lo defino como te muestro en el segundo bloque de código:

Este es el código en que me he basado:

        cmd.Transaction = tran
        cmd.ExecuteNonQuery()

        ' Si llega aquí es que todo fue bien,
        ' por tanto, llamamos al método Commit.
        tran.Commit()

        msg = "Se ha actualizado el Cliente correctamente."

    Catch ex As Exception
        msg = $"ERROR: {ex.Message}"
        ' Si hay error, deshacemos lo que se haya hecho.
        Try
            If tran IsNot Nothing Then
                tran.Rollback()
            End If
        Catch ex2 As Exception
            msg = $" (ERROR RollBack: {ex.Message})"
        End Try

    Finally
        con.Close()
    End Try

End Using

Return msg

Este es el código interno que uso en el conversor (el método generarClase):
En los comentarios está el código mostrado antes y el equivalente para generar el código de VB o de C#.

sb.AppendLine()
'         cmd.Transaction = tran
sb.AppendFormat("            {0}{1}", ConvLang.Asigna("cmd.Transaction", "tran"), vbCrLf)
'         cmd.ExecuteNonQuery()
sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("cmd.ExecuteNonQuery()"), vbCrLf)
sb.AppendLine()
'         ' Si llega aquí es que todo fue bien,
'         ' por tanto, llamamos al método Commit
sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Si llega aquí es que todo fue bien,"), vbCrLf)
sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" por tanto, llamamos al método Commit."), vbCrLf)
'         tran.Commit()
sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("tran.Commit()"), vbCrLf)
sb.AppendLine()
'         msg = "Se ha actualizado el Cliente correctamente."
sb.AppendFormat("            {0}{1}", ConvLang.Asigna("msg", """Se ha actualizado un " & nombreClase & " correctamente."""), vbCrLf)
sb.AppendLine()
'     Catch ex As Exception
sb.AppendFormat("            {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
'         msg = $"ERROR: {ex.Message}"
sb.AppendFormat("              {0}{1}", ConvLang.Asigna("msg", "$""ERROR: {ex.Message}"""), vbCrLf)
'         ' Si hay error, deshacemos lo que se haya hecho
sb.AppendFormat("              {0}{1}", ConvLang.Comentario(" Si hay error, deshacemos lo que se haya hecho."), vbCrLf)
'         Try
sb.AppendFormat("              {0}{1}", ConvLang.Try(), vbCrLf)
' Añadir comprobación de nulo en el objeto tran     (17-abr-21)
'   If tran IsNot Nothing Then
sb.AppendFormat("                  {0}{1}", ConvLang.If("tran", "IsNot", "Nothing"), vbCrLf)
'             tran.Rollback()
sb.AppendFormat("                        {0}{1}", ConvLang.Instruccion("tran.Rollback()"), vbCrLf)
' End If
sb.AppendFormat("                  {0}{1}", ConvLang.EndIf, vbCrLf)
'         Catch ex2 As Exception
sb.AppendFormat("              {0}{1}", ConvLang.Catch("ex2", "Exception"), vbCrLf)
'             msg &= $" (ERROR RollBack: {ex.Message})"
sb.AppendFormat("               {0}{1}", ConvLang.Asigna("msg", "$""ERROR RollBack: {ex2.Message}"""), vbCrLf)
'         End Try
sb.AppendFormat("              {0}{1}", ConvLang.EndTry(), vbCrLf)
sb.AppendLine()
sb.AppendFormat("            {0}{1}", ConvLang.Finally, vbCrLf)
' If Not (con is nothing) then
sb.AppendFormat("              {0}{1}", ConvLang.If("", "Not", "(con Is Nothing)"), vbCrLf)
'     con.Close()
sb.AppendFormat("                  {0}{1}", ConvLang.Instruccion("con.Close()"), vbCrLf)
' End If
sb.AppendFormat("              {0}{1}", ConvLang.EndIf, vbCrLf)
'     End Try
sb.AppendFormat("            {0}{1}", ConvLang.EndTry(), vbCrLf)
sb.AppendLine()
' End Using
sb.AppendFormat("            {0}{1}", ConvLang.EndUsing(), vbCrLf)
sb.AppendLine()
' Return msg
sb.AppendFormat("            {0}{1}", ConvLang.Return("msg"), vbCrLf)

Y el código generado de Visual Basic sería como te he mostrado arriba y el de C# sería más o menos este:

cmd.Transaction = tran;
cmd.ExecuteNonQuery();

// Si llega aquí es que todo fue bien,
// por tanto, llamamos al método Commit.
tran.Commit();

msg = "Se ha actualizado un Producto correctamente.";

}catch(Exception ex){
  msg = $"ERROR: {ex.Message}";
  // Si hay error, deshacemos lo que se haya hecho.
  try{
      if(tran  !=   null ){
            tran.Rollback();
      }
  }catch(Exception ex2){
   msg = $"ERROR RollBack: {ex2.Message}";
  }

finally{
  if(  !  (con  ==   null )){
      con.Close();
  }
}

}

return msg;

Como ves, no está bien formateado, (es el código generado directamente) pero si lo pegas en Visual Studio te lo formateará bien y lo coloreará mejor 😉

Y para muestra, ese trozo de código en un fichero abierto en Visual Studio 2022:
(Aunque todo hay que decirlo, en VB lo formatea bien, aunque solo sea un fichero abierto directamente (sin formar parte de ningún proyecto) mientras que en C# le he tenido casi que dar el formato manualmente, en fin…)

    cmd.Transaction = tran;
    cmd.ExecuteNonQuery();

    // Si llega aquí es que todo fue bien,
    // por tanto, llamamos al método Commit.
    tran.Commit();

    msg = "Se ha actualizado un Producto correctamente.";

}
catch(Exception ex)
{
      msg = $"ERROR: {ex.Message}";
      // Si hay error, deshacemos lo que se haya hecho.
    try
    {
        if (tran != null) 
        {
            tran.Rollback();
        }
    }
    catch(Exception ex2)
    {
        msg = $"ERROR RollBack: {ex2.Message}";
    }

    finally
    {
        if (!(con == null))
        {
          con.Close();
        }
    }
}

Pero la idea es que te quedes con lo que la clase hace.

También es cierto que yo suelo generar el código para Visual Basic y es lo que realmente he probado más, hoy he estado viendo cómo lo generaría para C# y he estado haciendo algunas correcciones (que he indicado en el fichero Revisiones.md publicado con GitHub).

Lo publicado originalmente en elGuilel.info

Los enlaces originales en www.elguille.info son estos:
– La página principal de la utilidad: Generar clases para acceder a una tabla.
– La página con el código y esas cosas: Utilidad para generar clases para acceder a una tabla.
– La página de actualización de cómo conseguir el código fuente: Esta me da error y estaba en CodePlex, ahora está en GitHub.

El final (del post)

Una captura de la utilidad tal como la tengo a día 1 de octubre de 2022.

Figura 1. La utilidad en funcionamiento a día de hoy 1 de octubre de 2022

Y esto es todo amigo (o amiga), ya sabes, si quieres participar en el proyecto para mejorarlo, puedes hacerlo, creo que en algún sitio indico cómo avisarme de los errores que encuentres y cómo actualizar el fichero Revisiones.txt que ahora es Revisiones.md.

Y si quieres usarlo sin más aportaciones, estaría bien que hicieras una pequeña aportación monetaria en PayPal (no es obligatorio, pero es de agradecer).

En breve publicaré en GitHub el ejecutable compilado con .NET Framework 4.8.1.

Nota:
Ya está publicado: gsCrearClaseTabla_20221001_1523.

Y ya sabes, si quieres ver el código fuente, está en el proyecto de GitHub (CrearClaseTabla).

Por cierto, en el proyecto (los dos) he incluido un fichero de nombre seguro (strong name) para firmar los ensamblados, ese fichero (elGuille_compartido.snk) lo puedes usar «libremente» (ya sabes todo está con la licencia MIT) para firmar los ensamblados con nombre seguro.

Espero que te sirva de utilidad.

Nos vemos.
Guillermo

P.S.
Sería interesante convertir el proyecto para .NET 6 (o 7) y también usando el código completamente en C#.
Actualmente está creado para usar con .NET Framework 4.8.1 y escrito enteramente en Visual Basic.

P.S.2
Ya está creado el proyecto para .NET 6.0 (net6.0-windows) y publicado en GitHub (gsCrearClasesTablas).

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

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

Un reloj para Windows escrito en C# por un VBer que quiere evolucionar (#evolveVB #evolucionarVB)

Pues eso… Este es un programa muy simple, bueno no tanto, lo que hace principalmente es mostrarte la fecha y la hora, actualizándose para que muestre los segundos, ¡es un reloj! ¡Pero aparte de la hora te muestro también la fecha hombre! 🙂

Nota del 4-dic-2020:
Ya está publicado el código de Visual Basic del Reloj Windows.
convertido del código de C# usando la utilidad CSharpToVB de paul1956.
Aquí tienes el enlace a Form1.vb en github.

 

Nota:
Esto no está repetido.
Es que lo he creado primero como página y ahora como entrada.
La página, a la que cambiaré el nombre, es para enlazarla en los proyectos de github, etc.

 

 

Versión en inglés / English version
En documentos de Google / In Google’s Documents.

 

En el código que después te pondré, puedes ver qué es y cómo se puede utilizar como una especie de salvapantalla. Otra de las cosas que le he añadido es que puedas acoplar la pantalla tanto a la izquierda como a la derecha, pero en la parte superior. Cuando se acopla se puede hacer al tamaño que tiene la pantalla actualmente o bien hacerlo a un tamaño mucho más pequeño, todo eso es configurable por medio del menú de opciones. También puede que te interese en el código es que puedes mover la pantalla pulsando sobre la fecha o sobre la hora, además de, por supuesto, pulsando en la barra de título como en cualquier aplicación. Y, aunque no tiene mucho misterio, el que a la ventana se pueda cambiar el nivel de opacidad o transparencia.
Te voy a pegar el texto que tengo en el menú de ayuda, acerca de, y así no me tengo que acordar de las cosas que le he ido añadiendo a esta aplicación.

 

El contenido de Acerca de:

Esta aplicación es un ‘simple’ reloj que te muestra la fecha y la hora en una ventana.

Te permite controlar dónde verla, si a tamaño normal, a tamaño pequeño, incluso puedes cambiar el tamaño a tu gusto.

Puedes hacer que esté encima del resto de ventanas.

Además puedes hacerla menos opaca (más transparente) para que pueda verse lo que hay debajo de la ventana.

El nivel de transparencia lo puedes controlar a tu gusto, desde casi totalmente transparente a totalmente opaca.

Puedes usarla también como una especie de salvapantallas (se va desplazando por la pantalla), pero con transparencia con idea de que veas lo que hay debajo sin tener que detener la aplicación.

Si quieres dejar de ver cómo se mueve por la pantalla, simplemente haz doble-clic en la fecha o en la hora.

El salvapantallas lo puedes usar a tamaño normal o en tamaño pequeño.

Cuando funciona como salvapantalla siempre está encima del resto de las ventanas y no muestra la barra de título.

La ventana la puedes mover desde la barra de título o bien manteniendo el ratón pulsado en la fecha o en la hora.

También puedes acoplarla en la parte superior izquierda o derecha, en esos casos, se cambia a tamaño mínimo y se hace transparente.

Y esto es casi todo… creo… en el menú de opciones (en el botón que hay abajo a la derecha) están todas las opciones de uso disponibles.

¡Disfrútala! 🙂

Capturas de la aplicación en funcionamiento

Aquí te muestro un par de capturas de la aplicación en modo normal y acoplada (que se muestra con transparencia).

Figura 1. Las opciones y cambiar la opacidad.

 

Figura 2. Acoplada en la parte superior izquierda (con transparencia)

 

Figura 3. Lista de las opciones del programa

 

El código no te lo voy a mostrar aquí, ya que son 680 líneas y no es plan… pero si podrás verlo en Github (ahora te pongo el enlace).

Este código por ahora está solo para C#, pero intentaré convertirlo para Visual Basic; cuando esté te avisaré o mejor aún, pásate por repositorio de Github y así podrás ver el código completo, de los dos lenguajes (recuerda que ahora mismo solo está el de C#).

Este es el repositorio de github: elGuille-info/Reloj-Windows: Reloj Windows es una aplicación que muestra la fecha y hora y se puede usar casi como un salvapantalla. Permite acoplarlo a la parte superior derecha o izquierda. (github.com)

El Documentos de Google pega el enlace con la descripción y todo… ¡mola! (cool!)

Este ha sido el segundo intento de usar la herramienta Dictado por voz, pero nada, a pesar de que en las sugerencias te dice que puedes decir punto y nueva línea, por ahora, de los signos de puntuación solo me ha reconocido el punto… en fin.

Y esto es todo… espero que te guste o al menos te sea de utilidad alguna parte del código.

Nos vemos.
Guillermo

P.S.
Sigo probando con C# y con Documentos de Google para ver si de una vez acaba entendiendo lo que digo 😉 (con el reconocimiento de voz o dictado por voz).

#evolveVB #evolucionarVB

Escribir código en C#. Guía para los developers de Visual Basic

Pues eso… Ahora que estoy empezando a escribir más programas en C# me doy cuenta de que esto de poner al final de cada sentencia un punto y coma es un poco engorroso. La idea sería que cuando se escribe una línea en C# al pulsar intro en el IDE de Visual Studio automáticamente le agregara el punto y coma al final. Esto lo he puesto como sugerencia en la Developer Community a ver si hacen caso, aunque no sé yo… si quieres ver esa sugerencia (Add automatically the semicolon (;) at the end when writing a new sentence in C# ), sigue el enlace.

Lo que si me he dado cuenta, o más bien, he confirmado, es que salvo excepciones y algunas características propias, escribir código en C# es casi como en Visual Basic. Por supuesto, si escribes una array debes usar corchetes [] en vez de paréntesis (), debes agregarle a todos los métodos sin parámetros los paréntesis al final, o la forma de escribir un simple if, tienes que acostumbrarte a poner entre paréntesis lo que vayas a comprobar con ese if.

Después hay cosas que son más raras (C# y otros lenguajes de la misma familia son expertos en esas rarezas que la gente de Visual Basic vemos como ganas de complicarse la vida, jejeje, pero bueno, es cuestión de ir acostumbrándose) por ejemplo el operador ternario de C# que en Visual Basic lo escribimos como un If(comprobación, valor si true, valor si false):

Dim s = If( valor, "Es True", "Es False")
dim s = if(valor,  "Es True" , "Es False")

en C# hay que hacerlo así:

var s = valor ? "Es True" : "Es False";
var s = valor ? "Es True" : "Es False";

Esto asigna a la variable s lo que corresponda, dependiendo de que la variable valor contenga un valor verdadero o falso.

Viendo el código de VB que te acabo de poner, parece que me contradigo con lo que he comentado de los ifs de C# (que hay que ponerlo entre paréntesis) pero es que este If que he usado en VB es un If especial, y sirve para lo que acabo de explicarte.

Si queremos usar un If normal podríamos hacerlo de la siguiente forma:

Dim s = ""
If valor Then
    s = "Es True"
Else
    s = "Es False"
End If
Dim s = ""
If valor Then
    s = "Es True"
Else
    s = "Es False"
End If

En C# sería algo así (se puede escribir con o sin llaves {}:

var s = "";
if( valor )
    s = "Es True";
else
    s = "Es False";
var s = "";
if( valor )
    s = "Es True";
else
    s = "Es False";

De esta forma, es para cuando después del if o del else solo hay una instrucción, si queremos poner más de una instrucción, debemos usar las llaves:

var s = "";
if( valor )
{
    s = "Es True";
}
else
{
    s = "Es False";
}
var s = "";
if (valor)
{
    s = "Es True";
}
else
{
    s = "Es False";
}

Y así… más cosas… como los bucles for, etc.

No voy a seguir porque no es plan de hacer un curso de cómo hacer las cosas en los dos lenguajes, de todas formas, en mi sitio (www.elguille.info) y en este blog los ejemplos de código que pongo los tengo en los dos lenguajes.

Y si te interesa saber algunas de las equivalencias entre Visual Basic .NET y C# las puedes encontrar en esta página (en realidad son 3 páginas de equivalencias):

Equivalencias entre VB.NET y C# (1) (elguille.info)

Equivalencias entre Visual Basic para .NET y C# (2) (elguille.info)

Equivalencias entre Visual Basic para .NET y C# (3) (elguille.info)

En otro momento le echaré un vistazo al contenido completo y veré si añado nuevas cosas, que las hay… ya que la última página la publiqué el 6 de agosto de 2006 y desde entonces (en estos más de 14 años) han salido cosas nuevas que hay que equiparar 😉 

Y esto es todo por ahora… mañana más (u otro día más).

Nos vemos.
Guillermo

#evolveVB #evolucionarVB

P.S.
Escrito en documentos de Google, intentando usar el dictado por voz, pero se ve que no me entiende tan bien o al menos no es mejor de lo que me esperaba… ya que parte de ese texto lo escribí usando Keep y dictándolo, pero como no había forma de añadir los puntos, coma, etc., he intentado con los documentos en la web usando Chrome.
Seguiré intentándolo… como con C#, a base de probar y probar al final se consigue lo que uno quiere 😉

P.S.2
El código en Github:
elGuille-info/escribir-codigo-en-csharp: Escribir código en C#. Guía para los developers de Visual Basic (github.com)

¿Te gustaría que a VB.NET le añadan nuevas características en .NET 5 (.NET Core)? pues… vota esta petición

Pues eso… que eso de que a los que preferimos VB sobre C# para crear nuestras aplicaciones (y aunque no lo prefiriéramos) no nos debería parecer bien que la gente de Microsoft haya decidido no añadir nuevas características al lenguaje, dejándolo estancado… es decir, que si bien podremos seguir usándolo no le van a añadir nuevas características. Por eso he publicado una petición en la comunidad de desarrolladores de Microsoft para ver si no lo dejan de lado.

Actualizado el 8-mar-2021

Esta es la respuesta de la gente de Microsoft (por Kathleen Dollar ex-MVP de Visual Basic que ahora trabaja en Microsoft):

Our strategy is here: https://devblogs.microsoft.com/vbteam/visual-basic-support-planned-for-net-5-0/

I do not think stabilizing the language blocks using new technologies in .NET 5.

Almost all new .NET 5.0 features are in the libraries and tools, which Visual Basic takes can use. Even features such ref struct which are not available in VB improve VB applications because they speed up operations in the BCL. And the BCL has a commitment to provide VB (and F#) friendly overloads for BCL features.

If there is a specific new feature, other than ref struct, that is blocking development, feel free to post a more specific issue.

Y de paso ha cerrado el hilo. Su respuesta es del 6 de enero de este año de 2021, aunque yo lo vi ayer, le respondí y Daniel Seara también y con más firmeza aún, jejeje

En fin… como le he contestado a Dani: Esto es lo que ahora nos podemos esperar los que usamos Visual Basic de la gente de desarrollo de Microsoft.

Es decir, ¡ahí te quedas, y búscate la vida!

En los enlaces que hay en el párrafo anterior están los enlaces a lo que comentó la gente del team de .NET sobre que Visual Basic no evolucionará como lenguaje aunque se podrá usar para generar aplicaciones de .NET 5.0 y .NET Core o .NET Standard (además de .NET Framework), pero te los repito: Visual Basic support planned for .NET 5.0 y la petición también la repito 😉 : Will be back Visual Basic evolve with C#?

Y la petición que yo te hago a tí que estás leyendo esto es que pinches en el enlace de la petición (este) y vote por esa petición, si te parece conveniente, claro, que tampoco te voy a obligar… ¡Faltaría más!

Y es que da la impresión de que los de Microsoft se han olvidado de todo (el dinero) que les ha dado Visual Basic (tanto para .NET como las versiones anteriores llamadas de forma genérica: VB6) y que lo abandonen de esa forma, mientras que F# si que seguirá evolucionando, que C# sea la estrella es porque está ligado 1 a 1 con el avance de .NET y por tanto debe seguir avanzando, tal como te expliqué en El porqué C# siempre tendrá novedades aunque Visual Basic ya no. Precisamente ahí te comenté lo que Anthony D. Green (un Program Manager de Visual Basic) opina sobre esto de que Microsoft no le dedique, al menos, la misma cantidad de persona que le dedica a F#, no, no tengo nada contra F#, solo que me extraña que un lenguaje que no usará ni la décima parte de la gente que usa VB.NET siga «palante» y VB no. Según ese señor, no sería necesario dedicarle más de tres personas (en nómina) aparte de los desarrolladores que quieran colaborar con el desarrollo (y la evolución) de Visual Basic. Si quieres, lee el artículo de Anthony y, aunque es un poco largo, deja muy claro las cosas.

Y ya no te canso más. Solo decirte que si te animas a votar favorablemente por la petición te explico cómo hacerlo:

Ve al sitio de Developer Community y accede a mi petición y pulsa en la flecha de arriba que está en la parte superior izquierda (ver la figura) para votar favorablemente, pero, por favor, no pulses en la flecha que señala para abajo, ya que quitarías votos… y no es plan 😉

Para votar a favor, pulsa en la flecha que señala para arriba. Gracias.

Agradecerte de antemano tu apoyo… y si quieres usar el hashtag (#evolvevb) pues mejor… que actualmente solo aparece un resultado y… no tiene nada que ver con evolucionar VB (que es lo que viene a significar evolveVB) 😉
Si quieres puedes usar #evolucionarVB para que todo quede en casa.

Por cierto, la Developer Community de Visual Studio está para añadir peticiones de nuevas características y para informar de bugs/fallos en Visual Studio y .NET.

Pues nada más… ¡gracias!

Nos vemos.
Guillermo