elGuille mola

Etiqueta: c#

  • Detectar varias pulsaciones de teclas en aplicación de Windows Forms (código para C# y Visual Basic)

    Pues eso… necesitaba saber cómo detectar varias pulsaciones de teclas al estilo de Ctrl+K, Ctrl+C y similares, es decir, se pulsa la tecla Control seguida de la K y se pulsa la tecla Control seguida de la C (como la combinación de Visual Studio para poner comentarios en la selección que haya en el código). Así que… busqué en internet, pero… había ejemplos muy enrevesados… con temporizadores y demás monadas… así que… basándome en algunos ejemplos (seguramente del mismo autor o copiados unos de otros) he hecho algo que puede servir… al menos a mí me sirve, aunque se puede mejorar, como todo.

    De la forma que lo he hecho da igual si se pulsa primero Ctrl+K que Ctrl+C, ya que lo que he intentado es que se sepa cuando se han hecho esas pulsaciones, y si entre cualquiera de las dos pulsaciones se ha pulsado otra tecla, no se tiene en cuenta esa combinación. Es decir si quieres detectar Ctrl+K seguida de Ctrl+C (que para el caso del código que te mostraré es lo mismo que si pulsas Ctrl+C seguida de Ctrl+K) pulsas otra tecla o combinación de teclas, no se dará como detectada esa doble pulsación.

    Nota:
    Precisamente con esas teclas: Ctrl+C y otras automatizadas de edición: Ctrl+V, Ctrl+X, Ctrl+P, etc., habría que tener cuidado o hacerle un seguimiento distinto al que ahora hago para que no la detecte y, por ejemplo pegue el texto si es Ctrl+P).

    ¿Dónde se hará la comprobación de la tecla pulsada?

    Las comprobaciones de qué tecla se está pulsando (o se ha pulsado) la hago en el evento KeyDown del formulario. Y como de forma predeterminada el formulario no intercepta las pulsaciones de las teclas, habrá que hacer una asignación de un valor verdadero (true) a la propiedad KeyPreview del formulario. Eso lo he puesto en el evento Load, con idea de que esté activado si por casualidad cambio el valor en el diseñador (esas cosas suelen ocurrir, y es complicado de saber porqué antes funcionaba y después no).

    En la figura 1 tienes una captura del código de ejemplo en funcionamiento (en ese caso la aplicación de C# creada con .NET Framework 4.8).

    Figura 1. La aplicación de ejemplo en funcionamiento.

    ¿Cómo saber si hay varias combinaciones de teclas?

    Lo que yo he hecho es crear unas variables para asignarles un valor si la combinación que se quiere detectar se cumple. Esas variables (o campos) definidas a nivel de la clase, las he declarado de tipo entero, (en los ejemplos que vi en la web eran de tipo Boolean, bool en C#), ya que lo que me interesa es saber si algunas de las combinaciones se ha hecho más de una vez, ese es el caso de Ctrl+K, Ctrl+K, es decir: pulsar dos veces la tecla Control y la tecla K.

    Si no quieres comprobar si hay una combinación que se haga más de una vez, lo mismo puedes usar variables de tipo Bolean (bool en C#), eso ya a tu discreción (o preferencia).

    Aquí te muestro el código con la definición de esas variables (tanto para VB como para C#):

    ' Para doble pulsación de teclas
Private CtrlK As Integer
Private CtrlC As Integer
Private CtrlU As Integer
Private CtrlL As Integer
Private ShiftAltL As Integer
Private ShiftAltS As Integer

    // Para doble pulsación de teclas
private int CtrlK;
private int CtrlC;
private int CtrlU;
private int CtrlL;
private int ShiftAltL;
private int ShiftAltS;

    Esas variables las usaremos en el evento KeyDown del formulario, incrementando el valor cuando se cumpla que se han pulsado las teclas indicadas, por ejemplo si queremos detectar la pulsación de Ctrl+K, tendremos que incrementar el valor de la variable CtrlK, ídem con el resto.

    Como en el ejemplo hay varias combinaciones de teclas que detectar, puede ser un poco largo de ver, pero prefiero que lo veas completo para que no te líes demasiado.
    Ahí se comprueban las tres posibles teclas de «control«, es decir, Control, Shift y Alt. También hago comprobaciones para que, por ejemplo, si queremos detectar Ctrl+Shift se haga en un bloque de código diferente para cuando se detecta, por ejemplo Ctrl+Alt o Shift+Alt.
    Creo que el código está bastante claro y no tendrás complicaciones de ver el proceso que se hace.

    Aquí tienes el código de VB y C#.

    Private Sub Form1_KeyDown(sender As Object, e As KeyEventArgs) Handles Me.KeyDown
        ' Comprobaciones para Ctrl+Shift

        ' esta de forma simple
        If e.Control AndAlso e.Shift Then
            If e.KeyCode = Keys.V Then
                e.Handled = True

                'MostrarRecortes();
                txtPulsadas.Text = "Capturada: Ctrl+Shift+V" & vbCrLf & txtPulsadas.Text

            End If

            ' Estas son con varias combinaciones

            ' Comprobaciones para Shift+Alt
        ElseIf e.Shift AndAlso e.Alt Then
            ' si se ha pulsado Shift+Alt+L
            If e.KeyCode = Keys.L Then
                e.Handled = True

                ShiftAltL += 1
                ' si se ha pulsado Shift+Alt+S
            ElseIf e.KeyCode = Keys.S Then
                e.Handled = True

                ShiftAltS += 1
            End If
            ' Si se ha pulsado Shitf+Alt+S, Shift+Alt+L
            ' (en cualquier orden)
            If ShiftAltL = 1 AndAlso ShiftAltS = 1 Then
                e.Handled = True

                'ClasificarSeleccion();
                txtPulsadas.Text = "Capturada: Shift+Alt+L, Shift+Alt+S" & vbCrLf & txtPulsadas.Text

            End If

            ' Comprobaciones para solo la tecla Ctrl (sin Shift ni Alt)
        ElseIf e.Control AndAlso Not e.Shift AndAlso Not e.Alt Then
            ' Solo se ha pulsado la tecla Ctrl
            ' comprobar el resto de combinaciones
            ' Forma simple si se ha pulsado Ctrl+B
            If e.KeyCode = Keys.B Then
                e.Handled = True

                ' Esta solo es para detectar
                ' la combinación 'simple' de Ctrl+B
                ' No es necesario llevar la cuenta de las pulsaciones
                txtPulsadas.Text = "Capturada: Ctrl+B" & vbCrLf & txtPulsadas.Text


            ElseIf e.KeyCode = Keys.K Then
                e.Handled = True

                CtrlK += 1
                txtPulsadas.Text = "Ctrl+K - " & txtPulsadas.Text

            ElseIf e.KeyCode = Keys.C Then
                e.Handled = True

                CtrlC += 1
                txtPulsadas.Text = "Ctrl+C - " & txtPulsadas.Text

            ElseIf e.KeyCode = Keys.U Then
                e.Handled = True

                CtrlU += 1
                txtPulsadas.Text = "Ctrl+U - " & txtPulsadas.Text

            ElseIf e.KeyCode = Keys.L Then
                e.Handled = True

                CtrlL += 1
                txtPulsadas.Text = "Ctrl+L - " & txtPulsadas.Text

            End If

            ' Si se ha pulsado Ctrl+K, CtrlC
            If CtrlK = 1 AndAlso CtrlC = 1 Then
                e.Handled = True

                ' Ctrl+K, Ctrl+C
                CtrlK = 0
                CtrlC = 0
                'PonerComentarios(richTextBoxCodigo);
                txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+C" & vbCrLf & txtPulsadas.Text


                ' Si se ha pulsado Ctrl+K, Ctrl+U
            ElseIf CtrlK = 1 AndAlso CtrlU = 1 Then
                e.Handled = True

                ' Ctrl+K, Ctrl+U
                CtrlK = 0
                CtrlU = 0
                'QuitarComentarios(richTextBoxCodigo);
                txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+U" & vbCrLf & txtPulsadas.Text


                ' Si se ha pulsado Ctrl+K, Ctrl+L
            ElseIf CtrlK = 1 AndAlso CtrlL = 1 Then
                e.Handled = True

                ' Ctrl+K, Ctrl+L
                CtrlK = 0
                CtrlL = 0
                ' preguntar
                'buttonEditorMarcadorQuitarTodos.PerformClick();
                txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+L" & vbCrLf & txtPulsadas.Text


                ' Si se ha pulsado Ctrl+K, Ctrl+K
            ElseIf CtrlK = 2 Then
                e.Handled = True

                ' Ctrl+K, Ctrl+K
                CtrlK = 0
                'MarcadorPonerQuitar();

                txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+K" & vbCrLf & txtPulsadas.Text

            End If
        Else
            txtPulsadas.Text = $"{vbCrLf}No es una de las teclas comprobadas: {e.KeyCode} +{vbCrLf}" &
                               $"    Ctrl: {e.Control}, Shift: {e.Shift}, Alt: {e.Alt}{vbCrLf}" & txtPulsadas.Text

            CtrlK = 0
            CtrlC = 0
            CtrlU = 0
            ShiftAltL = 0
            ShiftAltS = 0

            ' Otras pulsaciones
            ' No están detectadas explícitamente

        End If
    End Sub

    private void Form1_KeyDown(object sender, KeyEventArgs e)
{
    // Comprobaciones para Ctrl+Shift

    // esta de forma simple
    if (e.Control && e.Shift)
    {
        if (e.KeyCode == Keys.V)
        {
            e.Handled = true;

            //MostrarRecortes();
            txtPulsadas.Text = "Capturada: Ctrl+Shift+V\r\n" + txtPulsadas.Text;

        }
    }
            
    // Estas son con varias combinaciones

    // Comprobaciones para Shift+Alt
    else if (e.Shift && e.Alt)
    {
        // si se ha pulsado Shift+Alt+L
        if (e.KeyCode == Keys.L)
        {
            e.Handled = true;

            ShiftAltL += 1;
        }
        // si se ha pulsado Shift+Alt+S
        else if (e.KeyCode == Keys.S)
        {
            e.Handled = true;

            ShiftAltS += 1;
        }
        // Si se ha pulsado Shitf+Alt+S, Shift+Alt+L
        // (en cualquier orden)
        if (ShiftAltL == 1 && ShiftAltS == 1)
        {
            e.Handled = true;

            //ClasificarSeleccion();
            txtPulsadas.Text = "Capturada: Shift+Alt+L, Shift+Alt+S\r\n" + txtPulsadas.Text;

        }
    }

    // Comprobaciones para solo la tecla Ctrl (sin Shift ni Alt)
    else if (e.Control && !e.Shift && !e.Alt)
    {
        // Solo se ha pulsado la tecla Ctrl
        // comprobar el resto de combinaciones

        // Forma simple si se ha pulsado Ctrl+B
        if (e.KeyCode == Keys.B)
        {
            e.Handled = true;

            // Esta solo es para detectar
            // la combinación 'simple' de Ctrl+B
            // No es necesario llevar la cuenta de las pulsaciones
            txtPulsadas.Text = "Capturada: Ctrl+B\r\n" + txtPulsadas.Text;

        }

        else if (e.KeyCode == Keys.K)
        {
            e.Handled = true;

            CtrlK += 1;
            txtPulsadas.Text = "Ctrl+K - " + txtPulsadas.Text;

        }
        else if (e.KeyCode == Keys.C)
        {
            e.Handled = true;

            CtrlC += 1;
            txtPulsadas.Text = "Ctrl+C - " + txtPulsadas.Text;

        }
        else if (e.KeyCode == Keys.U)
        {
            e.Handled = true;

            CtrlU += 1;
            txtPulsadas.Text = "Ctrl+U - " + txtPulsadas.Text;

        }
        else if (e.KeyCode == Keys.L)
        {
            e.Handled = true;

            CtrlL += 1;
            txtPulsadas.Text = "Ctrl+L - " + txtPulsadas.Text;

        }

        // Si se ha pulsado Ctrl+K, CtrlC
        if (CtrlK == 1 && CtrlC == 1)
        {
            e.Handled = true;

            // Ctrl+K, Ctrl+C
            CtrlK = 0;
            CtrlC = 0;
            //PonerComentarios(richTextBoxCodigo);
            txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+C\r\n" + txtPulsadas.Text;

        }

        // Si se ha pulsado Ctrl+K, Ctrl+U
        else if (CtrlK == 1 && CtrlU == 1)
        {
            e.Handled = true;

            // Ctrl+K, Ctrl+U
            CtrlK = 0;
            CtrlU = 0;
            //QuitarComentarios(richTextBoxCodigo);
            txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+U\r\n" + txtPulsadas.Text;

        }

        // Si se ha pulsado Ctrl+K, Ctrl+L
        else if (CtrlK == 1 && CtrlL == 1)
        {
            e.Handled = true;

            // Ctrl+K, Ctrl+L
            CtrlK = 0;
            CtrlL = 0;
            // preguntar
            //buttonEditorMarcadorQuitarTodos.PerformClick();
            txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+L\r\n" + txtPulsadas.Text;

        }

        // Si se ha pulsado Ctrl+K, Ctrl+K
        else if (CtrlK == 2)
        {
            e.Handled = true;

            // Ctrl+K, Ctrl+K
            CtrlK = 0;
            //MarcadorPonerQuitar();

            txtPulsadas.Text = "Capturada: Ctrl+K, Ctrl+K\r\n" + txtPulsadas.Text;

        }
    }
    else
    {
        txtPulsadas.Text = $"\r\nNo es una de las teclas comprobadas: {e.KeyCode} +\r\n"+
                           $"    Ctrl: {e.Control}, Shift: {e.Shift}, Alt: {e.Alt}\r\n" + txtPulsadas.Text;
        CtrlK = 0;
        CtrlC = 0;
        CtrlU = 0;
        ShiftAltL = 0;
        ShiftAltS = 0;

        // Otras pulsaciones
        // No están detectadas explícitamente
    }
}

    Nota:
    En el código están comentadas las funciones / métodos a los que en el programa que uso esta forma de controlar las pulsaciones (múltiples) de teclas llama cuando se produce una. Así sabrás cuándo tienes que actuar cuando se produzca la pulsación esperada.

    Una aclaración sobre la diferencia entre KeyCode y KeyValue

    Hay gente que no se aclara entre los valores de esas dos propiedades del argumento KeyEventArgs del evento KeyDown (o KeyUp).

    KeyCode contiene el código de la tecla pulsada y el del tipo Keys (enumeración).
    KeyValue contiene el código de la tecla pulsada y el de tipo Integer (int en C#).

    En Visual Basic se puede usar indistintamente sin hacer nada especial, es decir, par saber si se ha pulsado la tecla B puedes hacerlo de estas dos formas:
    If e.KeyCode = Keys.B Then o If e.KeyValue = Keys.B

    Pero en C# no te permite hacer la comparación del valor int con un valor de la enumeración Keys. Si así lo quieres hacer, tendrías que hacer un cast al tipo entero:
    if (e.KeyValue == (int)Keys.B)

    Por tanto, es mejor usar e.KeyCode si la intención es compararla con un valor de Keys.

    Ya solo me queda ponerte el código completo de esta aplicación de prueba, pero como últimamente estoy haciendo (creo que solo lo he hecho una vez) ese código (tanto el de Visual Basic como el de C#) está en mis repositorios en GitHub, concretamente en varias-pulsaciones-de-teclas.

    Dicho código está creado en un proyecto para Visual Studio 2019 usando .NET Framework 4.8, pero también es válido para aplicaciones (de WinForms) creadas para .NET Core, al menos yo lo estoy usando en .NET 5.0 RC1.

    Y esto es todo… espero que te sea de utilidad.

    Nos vemos.
    Guillermo

  • 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 te sirva para manejar los eventos de un botón llamado buttonUndo y para un menú con nombre menuUndo y 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

  • El porqué C# siempre tendrá novedades aunque Visual Basic ya no

    Pues eso… el otro día estaba leyendo un artículo de Anthony D. Green (miembro del team de Visual Basic de Microsoft del 2010 al 2018) sobre todo lo relacionado con la que se lio por el tema de que a Visual Basic no se le añadirán nuevas características, (
    Future features of .NET Core that require language changes may not be supported in Visual Basic.), pero no es de eso de lo que te quiero hablar aquí. Es de lo que dice Anthony en su artículo.

    Concretamente esta parte es la que me ha hecho reflexionar un poco sobre C#:

    C# advances the .NET platform.
    I’m not begrudging or envying them that role but recognizing that that’s what the language has always done where VB is traditionally focused on innovation in experience.
    It’s not that you can’t write a library or a framework in VB (and people have) but the .NET platform is not and will never be dependent on the VB language (or F#) to make leaps.
    But if C# is late developing generics, .NET 2.0 doesn’t ship.
    If C# hasn’t figured out the shape and behavior of nullable value types those types can’t appear in any new APIs.
    If it’s late on LINQ, .NET 3.5 doesn’t ship.
    If async isn’t complete, .NET 4.5 can’t ship with new asynchronous APIs.
    If C# language design can’t converge on ref returns or nullable annotations the platform teams (like mscorlib) that depend on those features literally cannot ship their platforms for anyone.
    And for what it’s worth, C# is ALWAYS late on those things (a fact I learned too late) because getting it right takes all the time in the world.
    Which is why it’s insane (in hindsight) to envision an “ideal” world where you couple or serialize a language which does not fulfill that mission critical role with so many downstream dependencies and its customers’ productivity with one that does and expect good things for both of them.

    Extracto de: Un manual sobre por qué el sufrimiento crónico de la comunidad de VB.NET no es necesario ni una cuestión de gastos o practicidad

    Es decir, C# tiene que estar siempre actualizado ya que la plataforma .NET depende de C# (o casi). El casi es porque es el lenguaje de .NET que Microsoft tiene para poder usar las novedades que se agreguen a .NET.

    Y como ahora .NET ya no será una continua actualización de .NET Framework, si no de .NET Core (multiplataforma), es lógico que también deba incorporar las novedades enfocadas a ser utilizado tanto en Windows como en MacOS, Linux, iOS, Android, etcétera.

    ¿Debo olvidarme de Visual Basic y pasarme a C#?

    Esto no significa que a Visual Basic no se le deba seguir añadiendo nuevas características en el lenguaje, que según dice Anthony en su artículo es posible hacerlo si Microsoft dedica un par de profesionales a seguir manteniendo el lenguaje, que de otra parte puede recibir ayuda de la comunidad, como ya lo ha hecho con la última incorporación al lenguaje: Comentarios permitidos en más lugares dentro de las instrucciones que precisamente la ha agregado un participante de la comunidad: Paul1956 (Paul M Cohen).

    Lo que sí tendrá Visual Basic son nuevas funcionalidades en el editor de Visual Studio (ver figura 1), pero no tendrá, por ejemplo el equivalente a record (registro) o init (establecedor de solo inicialización) en las propiedades.

    Figura 1. Mostrar Inline parameters (parámetros en línea)

    Así que… si quieres tener un lenguaje de programación para .NET que esté siempre actualizado a las novedades de la plataforma .NET, debes decantarte por C#.

    Si no te gusta programar en C# pero sí en Visual Basic, recuerda que este último se quedará estancado en la versión 16.0, mientras que C# seguirá avanzando.
    Eso no significa que no puedas seguir usando Visual Basic.

    Pero si eres de los que quiere usar .NET 5.0 o las versiones que sigan apareciendo (cada año habrá una nueva y por tanto tendrá cosas nuevas), recuerda que podrás hacerlo, pero con las cosas que actualmente tiene Visual Basic.

    Y si eres de los que no quieren usar nada relacionado con .NET / .NET Core / .NET Standard, podrás seguir usando Visual Basic en .NET Framework 4.8 (o anteriores), aunque este último seguirá estando disponible mientras Windows exista.

    Resumiendo:
    No te quedarás obsoleto si sigues usando Visual Basic. Pero si quieres poder usar en tu código las novedades agregadas a .NET tendrás que plantearte el cambio a C#, aunque sea para poder crear alguna biblioteca de clases que utilice esas novedades de .NET y las pongas a disposición de tu código de Visual Basic (la cuestión es querer arreglar las cosas 😉 ).

    Aprender C#

    Y si quieres pasarte a C#, ya sabes que en elGuille.info (y en este blog) tienes un montón de código en C# con su equivalente en Visual Basic (o viceversa), ya que desde enero de 2001 (sí, hace ya 19 añitos de nada) todo (o prácticamente todo) lo que he ido publicando para Visual Basic (trucos, API, utilidades, WPF/XAML, etc.) está con el código para los dos lenguajes. Y, lo más importante: ¡TODO GRATIS! (aunque también puedes hacer una donación con PayPal 😉 ).

    Por supuesto también puedes apuntarte a algunos de los muchos cursos que hay en las plataformas de enseñanza online y aprender (pagando) el lenguaje C#.

    Cómo lo hagas, si decides hacerlo, es cuestión tuya.

    Por mi parte, seguiré usando Visual Basic como lenguaje de programación principal, sin olvidarme de C# e ir aprendiendo las cosas nuevas que vayan apareciendo.
    Tanto de uno como de otro lenguaje, iré publicando artículos para que te sirva de aprendizaje o para que te aclares un poco más

    En un próximo artículo te explicaré algunas de las novedades de C# 9.0 como son los tipos de registro (record), inicializadores en las propiedades (init) o instrucciones de nivel superior (Top-level statements).

    Nos vemos.
    Guillermo

    P.S.
    Traducción (automatizada del párrafo en inglés):

    C# avanza la plataforma .NET.
    No les estoy regateando ni envidiándoles ese papel, pero reconozco que eso es lo que siempre ha hecho el lenguaje, donde VB se centra tradicionalmente en la innovación en la experiencia.
    No es que no pueda escribir una biblioteca o un marco de trabajo en VB (y la gente lo ha hecho), pero la plataforma .NET no depende y nunca dependerá del lenguaje VB (o F #) para avanzar.
    Pero si C# desarrolla genéricos tarde, .NET 2.0 no sale.
    Si C# no ha descubierto la forma y el comportamiento de los tipos de valores que aceptan valores NULL, esos tipos no pueden aparecer en ninguna API nueva.
    Si llega tarde en LINQ, .NET 3.5 no se distribuye.
    Si async no está completo, .NET 4.5 no se puede enviar con nuevas API asincrónicas.
    Si el diseño del lenguaje C# no puede converger en devoluciones de referencia o anotaciones que aceptan valores NULL, los equipos de la plataforma (como mscorlib) que dependen de esas características, literalmente, no pueden enviar sus plataformas a nadie.
    Y por si sirve de algo, C# SIEMPRE llega tarde en esas cosas (un hecho que aprendí demasiado tarde) porque hacerlo bien lleva todo el tiempo del mundo.
    Es por eso que es una locura (en retrospectiva) imaginar un mundo «ideal» en el que se acopla o serializa un lenguaje que no cumple esa función crítica con tantas dependencias posteriores y la productividad de sus clientes con uno que sí y espera cosas buenas para ambos.