Лучший способ написать метод расширения для вызова элемента управления?

Во-первых, позвольте мне сказать, что вы, возможно, слишком много думаете об этом — короткий код — это здорово, но есть момент, когда он начинает сбивать с толку любого, кто пытается прочитать код.

Теперь ваше первое предложение:

button1.Invoke(Hide);

может работать, если вы сделаете это:

button1.Invoke(button1.Hide); 

потому что иначе компилятор не может знать, где искать метод Hide(). Это может даже вызвать странное поведение, например, если весь этот код находится в каком-то производном классе, например:

class A : Control {
    public A() {
         Button button1=new Button();
         button1.Invoke(Hide);
    }
}

Теперь он будет компилироваться, но метод Hide() будет методом Hide() всего элемента управления, а не кнопки! Способ добиться этого прост:

public static void Invoke(this Control c, Action action) {
    c.Invoke(action);
}

Последний способ:

button1.Hide().Invoke();

будет работать даже без добавления методов расширения, вам просто нужно сделать это:

((Action)button1.Hide).Invoke();

Это, конечно, означает, что метод Hide() вызывается в текущем потоке, что, вероятно, не то, что вам нужно. Так сделайте это:

((Action)button1.Hide).Invoke(button1);
public static void Invoke(this Action action, Control c) {
    c.Invoke(action);
}

Извините за длинный ответ, надеюсь, это поможет.

Чтобы построить другие ответы, я бы поместил это в отдельный класс расширения.

public static void Invoke<T>(this T c, Action<T> action) where T : Control
    {
        if (c.InvokeRequired)
            c.Invoke(new Action<T, Action<T>>(Invoke), new object[] { c, action });
        else
            action(c);
    }

Это предотвратит выбрасывание TargetParameterCountException при кросс-поточности.

Звонить:

button1.Invoke(x => x.Hide());

Вы можете использовать SynchronizationContext.Post или SynchronizationContext.Send, чтобы платформа упорядочивала действие для поток пользовательского интерфейса, будь то Windows Forms или WPF. Статический метод SynchronizationContext.Current возвращает соответствующий контекст синхронизации для вашего типа приложения.

Post выполняется асинхронно, тогда как Send блокируется до завершения действия.

Следующий код асинхронно скроет кнопку:

SynchronizationContext.Current.Post(_=>button1.Hide(),null);

Я бы пошел с:

public static void Invoke<T>(this T c, Action<T> action) where T : Control
{
    if (c.InvokeRequired)
        c.TopLevelControl.Invoke(action);
    else
        action(c);
}

а также

button.Invoke(c => c.Hide());

Это самый чистый (вам дается первоначально указанная кнопка для выполнения действия) и самый безопасный (вам не нужно указывать button1 дважды... он возвращается вам как параметр вашей лямбда-выражения) ). Я считаю, что это элегантный синтаксис.

Это определенно нельзя сделать как button1.Invoke(Hide); или button1.Hide.Invoke(); из-за ограничений синтаксиса C#.

Но если вы готовы отказаться от IntelliSense, вы можете сделать его немного короче. Как недостаток, некоторые ошибки, которые обычно можно обнаружить и исправить во время компиляции (например, опечатки или несоответствие параметров), станут ошибками времени выполнения. Иногда это приемлемо, иногда нет.

Забегая вперед, вот пример использования:

button1.Invoke("Hide");

or

button1.Invoke("ResumeLayout", true);

Решение:

internal static class ExtensionMethods
{
    internal static object Invoke<TControl>(this TControl control,
        string methodName, params object[] parameters)
        where TControl : Control
    {
        object result;

        if (control == null)
            throw new ArgumentNullException("control");

        if (string.IsNullOrEmpty(methodName))
            throw new ArgumentNullException("methodName");

        if (control.InvokeRequired)
            result = control.Invoke(new MethodInvoker(() => Invoke(control,
                methodName, parameters)));
        else
        {
            MethodInfo mi = null;

            if (parameters != null && parameters.Length > 0)
            {
                Type[] types = new Type[parameters.Length];
                for (int i = 0; i < parameters.Length; i++)
                {
                    if (parameters[i] != null)
                        types[i] = parameters[i].GetType();
                }

                mi = control.GetType().GetMethod(methodName,
                    BindingFlags.Instance | BindingFlags.Public,
                    null,  types, null);
            }
            else
                mi = control.GetType().GetMethod(methodName,
                    BindingFlags.Instance | BindingFlags.Public);

            if (mi == null)
                throw new InvalidOperationException(methodName);

            result = mi.Invoke(control, parameters);
        }

        return result;
    }