Archivo de la etiqueta: csharp

Crear métodos de evento con expresiones lambda para asignarlos manualmente (VB y C#)

Pues eso… hoy te voy a explicar cómo crear métodos lambda (o métodos de evento que usan expresiones lambda) para asignar a los eventos de los controles. Esto lo estoy usando últimamente hasta que la gente de Visual Studio mejore el diseñador de formularios para .NET 5.0 (y .NET Core 3.1) ya que… deja mucho que desear y da muchos quebraderos de cabeza… nada que ver con el diseñador de WinForm (Windows.Forms Designer) de .NET Framework.

Pero aparte de que el editor tenga sus cosas que hay que arreglar… y la verdad no sé si lo arreglarán, ya que ni con el diseñador de formularios de C# va bien. Y no ya porque esté usando el Visual Studio 2019 Preview (actualmente tengo instalada la versión 16.8.0 Preview 3.1, que es la última que hay a día de hoy 28 de septiembre de 2020), si no porque tampoco va en la versión normal de Visual Studio y con el .NET Core soportado, que es la versión 3.1.

Figura 1. Código del ejemplo en el editor de Visual Studio 2019 (VB y C#)

Antes de seguir con el código de ejemplo, te explico lo que dice la documentación de Microsoft (Microsoft docs) sobre las expresiones lambda en Visual Basic.

Y esta es la definición de las expresiones lambda en C#.

¿Qué son las expresiones lambda?

Definición en la documentación de Visual Basic:

Una expresión lambda es una función o subrutina sin un nombre que se puede usar siempre que un delegado sea válido. Las expresiones lambda pueden ser funciones o subrutinas y pueden ser de una o varias líneas. Puede pasar valores del ámbito actual a una expresión lambda.

Lambda (expresiones) (Visual Basic) en la Documentación de Microsoft.

Definición en la documentación de C#:

Una expresión lambda es una expresión que tiene cualquiera de estas dos formas:
Una lambda de expresión que tiene una expresión como cuerpo:
(input-parameters) => expression

Una lambda de instrucción que tiene un bloque de instrucciones como cuerpo:
(input-parameters) => { <sequence-of-statements> }

Use el operador de declaración lambda => para separar la lista de parámetros de la lamba de su cuerpo. Para crear una expresión lambda, especifique los parámetros de entrada (si existen) a la izquierda del operador lambda y una expresión o bloque de instrucciones en el otro lado.

Expresiones lambda (referencia de C#) en la documentación de Microsoft.

Lo que dice la documentación sobre el operador =>
El token => se admite de dos formas: como el operador lambda y como un separador de un nombre de miembro y la implementación del miembro en una definición de cuerpo de expresión.

Ejemplos de expresiones lambda

Imagina que quieres asignar al evento Click de un botón llamado buttonAbrir y cuando se produzca quieres indicarle que llame al método Abrir, en lugar de crear un método específico, que de forma predeterminada tendrá el siguiente aspecto:

Private Sub buttonAbrir_Click(sender As Object, e As EventArgs) Handles buttonAbrir.Click
Abrir()
End Sub

Puedes hacerlo de esta otra forma (por ejemplo dentro del evento Load del formulario):

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load

    AddHandler buttonAbrir.Click, Sub() Abrir()

End Sub

En este último de ejemplo, se crear el método de evento usando una expresión lambda, que como ves solamente usa Sub(), sin argumentos. Esto es así porque Visual Basic lo permite. Si eso mismo se hiciera con C# habría que indicar expresamente los parámetros de esa expresión lambda, aquí te muestro el mismo código (o casi) pero para C#.

private void Form1_Load(object sender, EventArgs e)
{
    buttonAbrir.Click += (object o, EventArgs e) => Abrir();
}

El casi, es porque en algún sitio del código de C# hay que asignar el método Form1_Load al evento Load del formulario (que sería el equivalente al Handles Me.Load del código de Visual Basic):

this.Load += Form1_Load;

Todo este código mostrado sería la forma más simple de asignar una expresión lambda para indicar el método que manejará el evento.

Utilizar el mismo método de evento (o expresión lambda) en varios controles

Pero imagina que quieres hacer la misma asignación de una expresión lambda en varios controles.

Si los controles están declarados con WithEvents y estás usando el diseñador de Windows Forms de Visual Studio para una aplicación de .NET Framework, podrías hacer algo como esto para que el método variosUndo_Click que para manejar los eventos de un botón llamado buttonUndo y para un menú con nombre menuUndo estaría definido de esta forma:

Private Sub variosUndo_Click(sender As Object, e As EventArgs) _

                    Handles buttonUndo.Click, menuUndo.Click

    If richTextBoxCodigo.CanUndo Then richTextBoxCodigo.Undo()
End Sub

Nota:
En C# (que yo sepa) no hay equivalente para esto, habría que asignar de forma independiente cada manejador de evento.

Sigamos con el código para usar una expresión lambda para hacer lo mismo que en el ejemplo anterior.

Lo primero es definir la expresión lambda:

Private lambdaUndo As EventHandler =  _
           Sub(sender As Object, e As EventArgs) _
               If richTextBoxCodigo.CanUndo Then richTextBoxCodigo.Undo()

Nota:
He usado los guiones bajos para que el código sea más legible.
La he declarado explícitamente como del tipo EventHandler porque están declaradas en el cuerpo del la clase. Si estuviese dentro de un método puedes declararlas con:
Dim lambdaUndo = Sub

Y la asignación a los eventos de esos dos controles antes mencionados (buttonUndo y menuUndo) la haremos de esta forma:

AddHandler buttonUndo.Click, lambdaUndo
AddHandler menuUndo.Click, lambdaUndo

Y ya que estamos, y para terminar, te muestro el equivalente al código anterior, pero sin haber declarado la variable (con la expresión lambda) lambdaUndo:

' Usando expresión lambda no definida previamente
AddHandler buttonUndo.Click, _
  Sub() If richTextBoxCodigo.CanUndo Then richTextBoxCodigo.Undo() AddHandler menuUndo.Click, _
  Sub() If richTextBoxCodigo.CanUndo Then richTextBoxCodigo.Undo()

C# no permite definir expresiones lambda a nivel de clase si accede a miembros no estáticos

En C# no podemos definir la expresión lambda a nivel de clase si accede a un miembro no estático de dicha clase. En VB si se puede (como has podido comprobar).
Así que, si queremos definirlo a nivel de clase, habrá que tener en cuenta que si accede a algún control u otro objeto declarado en esa clase, deben estar definidos con la cláusula static.

Aquí tienes la forma de hacer lo mismo que en el código de Visual Basic (he añadido la definición de richTextBoxCodigo como estático (compartido, Shared en Visual Basic):

// En C# no permite declararlo fuera del cuerpo de un método
// si no, da error de que el control no está definido (debe ser static)
// A field initializer cannot reference the non-static field, method or property 'Form1.richTextBoxCodigo'
// por tanto: definiendo el richtextbox como static ya funciona

private static RichTextBox richTextBoxCodigo;

private EventHandler lambdaUndo = 
            (object sender, EventArgs e) => 
            {
                  if(richTextBoxCodigo.CanUndo) richTextBoxCodigo.Undo();
            };


    // Usando expresión lambda definida previamente
    buttonUndo.Click += lambdaUndo;
    menuUndo.Click += lambdaUndo;

Nota:
Al definir los parámetros de la expresión lambda en C# no es necesario indicar el tipo de datos de cada argumento, con indicar los nombres de los identificadores (variables) es suficiente, tal como te moestraré en otro ejemplo.

Una cosa interesante, y a tener en cuenta, en la definición de la expresión lambda asignada a la variable lambdaUndo es que se usa una expresión if como resultado. En ese caso es obligatorio usar las llaves de apertura y cierre: { };, si no, dará error.
Cuando se usa una llamada a un método no es necesario ponerlo entre las llaves.

Lo de interesante en el párrafo anterior es porque en los ejemplos que vi en internet, para saber porqué no podía declarar (sin errores) esa expresión lambda, no encontré ninguno que usara una expresión al estilo del if, todos los ejemplos eran usando llamadas a métodos o como si fuesen la definición de una llamada a un método. Y además el único ejemplo que me topé definiendo la expresión lambda en el cuerpo de la clase, llamaba a MessageBox y nada que me aclarara las dudas.

Sí, puedes estar pensando que si hubiese hecho caso al mensaje ese de que un inicializador de un campo no puede referenciar a un método no estático, etc. (A field initializer cannot reference the non-static field, method or property ‘Form1.richTextBoxCodigo’) me lo decía todo, pero es que antes de que me mostrase ese mensaje me decía un montón de cosas que no tenían nada que ver con eso.

Aquí tienes todos los errores que mostraba al asignar ese método anónimo sin usar las llavecitas de las narices…

Lista de los errores mostrados al no usar las llaves alrededor de la expresión if.
Y todos en la misma línea (la 39) que es la que define lambdaUno de esta forma (que ya sabemos que es errónea):
private EventHandler lambdaUndo = (object sender, EventArgs e) => if(richTextBoxCodigo.CanUndo) richTextBoxCodigo.Undo();

Error CS1525  Invalid expression term 'if'
Error CS1003  Syntax error, ',' expected
Error CS1002  ; expected
Error CS8124  Tuple must contain at least two elements.
Error CS0246  The type or namespace name 'richTextBoxCodigo' could not be found (are you missing a using directive or an assembly reference?)
Error CS0246  The type or namespace name 'richTextBoxCodigo' could not be found (are you missing a using directive or an assembly reference?)
Error CS0538  'richTextBoxCodigo' in explicit interface declaration is not an interface
Error CS0501  'Form1.Undo()' must declare a body because it is not marked abstract, extern, or partial

Nota:
Ahora que he copiado la definición de las expresiones lambda en la documentación de C# (para pegarla arriba), al ver lo que en esa documentación llaman lambda de instrucción, veo que ahí se indica que hay que encerrar la expresión entre llaves.

En mi defensa te dirá que la documentación de C# la he leído cuando estaba revisando lo que ya había escrito hasta después del siguiente ejemplo. En fin…
Aunque lo mismo tampoco me hubiese enterado…

¡Qué torpe es el Guille!

La otra solución es definir esa expresión lambda dentro del método que sea, por ejemplo Form1_Load.
En este caso no tenemos que definir el control richTextBoxCodigo como static y la expresión lambda la definimos dentro del evento Load del formulario.
Esto está bien si no necesitamos usar esa expresión lambda imbuida en una variable en algún otro método de esa clase.

Este sería el código de ejemplo:

    private void Form1_Load(object sender, EventArgs e)
    {

        EventHandler lambdaUndo = (sender, e) => 
            {
                if (richTextBoxCodigo.CanUndo) richTextBoxCodigo.Undo();
            };

        // Usando expresión lambda definida previamente
        buttonUndo.Click += lambdaUndo;
        menuUndo.Click += lambdaUndo;

    }

Pero en mi caso en particular esta última solución no me sirve, ya que esa expresión lambda la tenía que usar en varios métodos de la misma clase.

Nota (repetimos):
Al definir los parámetros de la expresión lambda en C# no es necesario indicar el tipo de datos de cada argumento, con indicar los nombres de los identificadores (variables) es suficiente, tal como te muestre en el código anterior.

Y hasta aquí hemos llegado… (el fin) aunque en realidad no es el fin del todo… ya sabes que habrá más, concretamente te mostraré un método de extensión para el tipo ToolStripMenuItem para que sirva para clonar un elemento menú, con idea de asignar una copia a otro menú.
Yo eso lo hago cuando quiero añadir un menú contextual que tenga los mismos (o algunos) elementos que otro menú. Por ejemplo a la hora de usar los comandos de edición en un control de texto, para que se muestren los que me interesen del menú de edición. Pero eso será otro día

El código de ejemplo para C# y Visual Basic

He publicado el código de ejemplo en GitHub, en la forma de un fichero Form1.
Por supuesto, el código de C# está en Form1.cs y el de Visual Basic en Form1.vb

Nos vemos.
Guillermo

Fallo en el editor de código de VB y C# en Visual Studio 2019

Pues eso… estaba yo tan tranquilo escribiendo código en un formulario de Windows Forms cuando pasé al diseñador a mirar algún evento o nombre de un control y cuando volví al código… ¡HABÍA DESAPARECIDO!

Noté que después de cambiar del diseñador al panel de código el asterisco (*) de modificado había desaparecido… Y (seguramente) la posición en el editor de código era la misma que cuando abrí el proyecto. Así que… me puse puse a buscar lo que había escrito (por si se hubiese cambiado la posición dentro del editor) y ¡el código no estaba!

Era raro… muy raro…

Menos mal que se me ocurrió darle al botón DESHACER. ¡Y el código volvió a aparecer! (Y el asterisco de modificado también).

Todo esto era en un proyecto para Visual Basic usando Visual Studio 2019 Community «normal», aunque después probé en la Preview y también ocurre.

El problema

Para un ejemplo de lo que ocurre ver el GIF animado de la figura 1 para que te hagas una idea.

Figura 1. Fallo en el editor de formularios de Visual Studio 2019 usando Visual Basic

Lo de mostrar la versión de Visual Studio es porque este GIF (y los que te voy a mostrar después) los mandé la notificación del problema a la comunidad de desarrollo (Developer Community).
Ya que ellos (después de explicarles varias veces los pasos a seguir) no consiguieron reproducirlo y en sus capturas me mandaban la versión de Visual Studio que estaban usando.

 

Nota del 18/Sep:
Dicen que lo están investigando:
This issue is currently being investigated. Our team will get back to you if either more information is needed, a workaround is available, or the issue is resolved.
A ver qué ocurre…

 

Los pasos a seguir, al menos así es como me ocurría más a menudo (aunque no siempre ocurría) son estos:

1- Con cualquier proyecto de Visual Basic (al principio pensé que solo ocurre en VB, pero después comprobé que también ocurre en C#) deja abierto el formulario en modo de diseño y la ventana de código, de forma que el código tenga el foco antes de cerrar la solución (o el Visual Studio).
2- Al abrir nuevamente Visual Studio, te mostrará la ventana de código.
3- Escribe lo que sea y pasa a la ventana del diseñador de formularios.
4- Vuelve a la ventana del editor y verás que el código antes escrito desaparece.
5- Si lo quieres recuperar, tendrás que pulsar en el botón de deshacer.
5a- En al menos una ocasión (creo que con la versión Preview y un proyecto de C# para .NET 5.0 Preview 8) mostró un aviso de que se perderán los cambios en el diseñador (o algo así, no le presté atención ya que no pensaba que iba a ocurrir esto de perder el código), pero al darle varias veces a deshacer, el código volvió.

Pruebas y más pruebas

Este problema no ocurre siempre, ese es realmente el problema.

Para comprobar los fallos (y porque los de Microsoft me pidieron que les enviara un proyecto en el que ocurriera) creé un nuevo proyecto de Windows Forms para Visual Basic con .NET Framework 4.7.2 y, tras varias pruebas, se reprodujo el problema.

También probé con proyectos de C#, tanto con la versión normal de Visual Studio como con la versión Preview. Pero no era capaz de que volviese ocurrir en C#, pero sí en VB. Así que… pensé que solo ocurría esto en los proyectos de los pobres y ya casi abandonados usuario de Visual Basic.

Pero no: El problema también ocurre con proyectos de C#.
Más sobre esto dentro de un momento.

Usar una máquina virtual en Azure preparada para Visual Studio 2019

Los de Microsoft (concretamente John Q., me preguntaron si esto mismo me ocurría en otros equipos o le ocurría a otros desarrolladores de mi equipo… ¡sic! ¡Solo tengo a un desarrollador en mi equipo! Y no, no tengo otros equipos (máquinas) en la que poder probarlo… Se me ocurrió que podría probarlo en una máquina virtual… Pero me daba pereza crear una máquina virtual, instalar el Visual Studio y probarlo, así que… se me ocurrió probarlo en una máquina virtual de Azure.

Me creé una cuenta «FREE» de Azure (la que yo tenía ya caducó hace meses) con idea de usar allí una máquina virtual, pero la pereza era la misma… tener que crear una máquina virtual y tener que instalar el Visual Studio.

Sé que hay (o al menos había) máquinas virtuales ya preparadas con Visual Studio y que Microsoft las pone a nuestra disposición, así que… me puse a buscarla y encontré esto en la documentación de Microsoft: Imágenes de Visual Studio en Azure.
Uno de los enlaces activos era este: Visual Studio 2019: versión más reciente (16.5), pero el enlace estaba roto y no mostraba nada (salvo un error 404).

Así que… usé el enlace para Azure Marketplace (en la misma página de las imágenes de Visual Studio en Azure) y también daba error 404. Pulsé en el enlace de esa misma página que indica Ir a Azure Marketplace y con un poco de paciencia la página apareció) y entré en el apartado Apps. Filtré para que me mostrase solo las de Microsoft como publisher para el sistema operativo Windows y el tipo de producto Virtual Machine Images.

Y allí estaba: Visual Studio 2019 Latest.

Figura 2. La máquina virtual de VS para Azure


Al pulsar el enlace (no me deja copiarlo) muestra una ventana pop-up con las opciones que hay para seleccionar, primero seleccioné la versión Community para Windows 10, pero no me dejó instalarla, así que… posteriormente elegí la versión Visual Studio 2019 Comunity (latest release) on Windows Server 2019 y esa sí funcionó.

Probando a repetir el problema con Visual Studio en la máquina virtual de Azure

Allí probé el proyecto que les mandé y tras no-se-cuantas-miles-de-pruebas, el problema no se repetía.

Lo más que me ocurrió fue algo que también me ha ocurrido más veces (y seguramente tendrá que estar en una nuevo problema para que lo resuelvan) y es que al pasar o mostrarse directamente la ventana de código al abrir el proyecto, esta se muestra totalmente en blanco, tal como puedes comprobar en la figura (GIF) número 3.

Figura 3. Cuando te quedas en blanco mientras escribes código… o casi 😉

Pero el fallo inicial no se reproducía en el proyecto de prueba de Visual Basic.

El problema también ocurre con proyectos de C#

Así que… me dio por crear un nuevo proyecto de C# para Windows Forms usando .NET Core 3.1, así de paso probaba qué características tiene ese tipo de proyecto, ya que con los de Visual Basic para .NET 5.0 Preview 8, son una caca… también para C#, ya que no puedes hacer casi nada en el diseñador de formularios, al menos no puedes enlazar los eventos ni editar visualmente los menús, etc., pero esa es otra historia.

Y el fallo volvió a ocurrir… ya no recuerdo si fue a la primera o a la segunda… y eso que fue ayer… la cuestión es que funcionó y yo tenía la utilidad ScreenToGif lista para capturar los movimientos.

Y los capturé, y en la figura 4 puedes ver que con un proyecto de C# también ocurre.

Figura 4. El fallo de perder lo escrito en un proyecto de C#

Fíjate en el detalle de que antes de mostrar el diseñador de formularios aparece un mensaje indicando algo como Opening the file… si eso se muestra… ¡es prácticamente seguro que el fallo va a ocurrir!

 

Y esto es todo… a ver si lo solucionan.

Lo que si es cierto es que hay más cosas que pasan, aparte de que escribas código y se pierda o se quede la ventana de código en blanco, ya que también me ocurre que estando en el diseñador de formularios no se muestra la ventana de propiedades y tengo que cambiar a otra pestaña o cerrar y abrir el formulario para que por fin se muestre la ventana de propiedades o que al estar en la ventana de propiedades, en el despegable donde indica qué control estás mostrando esté en blanco y aún así se muestren algunas propiedades… esto último me pasó en el proyecto de C# para .NET Core 3.1 en el que tenía seleccionado un botón que quería moverlo o cambiar el valor de la propiedad Anchor y al no mostrarse esa propiedad pensé que en .NET Core 3.1 no existía esa propiedad… y no, era que fallaba la ventana de propiedades.

Si te ha ocurrido algo de esto, por favor indícalo en la página esa de Developer Community en la que he publicado el fallo (la descripción del problema está en inglés), te repito el enlace para que te sea más cómodo:

When opening a project if I modify the code and then (without saving) I show the form, when returning to the code that code does not exist (any changes made are not shown).

Es un título largo, lo sé… pero… 😉

Gracias.

Nos vemos.
Guillermo