Archivo de la etiqueta: github

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