Automatyzacja wywoływanego wzorca kodu

Możesz napisać metodę rozszerzenia:

public static void InvokeIfRequired(this Control c, Action<Control> action)
{
    if(c.InvokeRequired)
    {
        c.Invoke(new Action(() => action(c)));
    }
    else
    {
        action(c);
    }
}

I użyj go w ten sposób:

object1.InvokeIfRequired(c => { c.Visible = true; });

EDIT: jak zaznacza Simpzon w komentarzach można też zmienić podpis na:

public static void InvokeIfRequired<T>(this T c, Action<T> action) 
    where T : Control

Oto formularz, którego używam w całym kodzie.

private void DoGUISwitch()
{ 
    Invoke( ( MethodInvoker ) delegate {
        object1.Visible = true;
        object2.Visible = false;
    });
} 

Oparłem to na wpisie na blogu tutaj . Nie miałem takiego podejścia, więc nie widzę powodu, aby komplikować mój kod z sprawdzeniem właściwości InvokeRequired.

Utwórz ThreadSafeInvoke.urywek pliku, a następnie możesz po prostu wybrać Instrukcje aktualizacji, kliknąć prawym przyciskiem myszy i wybrać " Surround With...'lub Ctrl-K + S:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>ThreadsafeInvoke</Title>
    <Shortcut></Shortcut>
    <Description>Wraps code in an anonymous method passed to Invoke for Thread safety.</Description>
    <SnippetTypes>
      <SnippetType>SurroundsWith</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Code Language="CSharp">
      <![CDATA[
      Invoke( (MethodInvoker) delegate
      {
          $selected$
      });      
      ]]>
    </Code>
  </Snippet>
</CodeSnippet>

Oto ulepszona / połączona Wersja odpowiedzi Lee, Olivera i Stephana.

public delegate void InvokeIfRequiredDelegate<T>(T obj)
    where T : ISynchronizeInvoke;

public static void InvokeIfRequired<T>(this T obj, InvokeIfRequiredDelegate<T> action)
    where T : ISynchronizeInvoke
{
    if (obj.InvokeRequired)
    {
        obj.Invoke(action, new object[] { obj });
    }
    else
    {
        action(obj);
    }
} 

Szablon pozwala na elastyczny i mniej rzucany kod, który jest znacznie bardziej czytelny, podczas gdy dedykowany delegat zapewnia wydajność.

progressBar1.InvokeIfRequired(o => 
{
    o.Style = ProgressBarStyle.Marquee;
    o.MarqueeAnimationSpeed = 40;
});

Wolałbym używać pojedynczej instancji delegata metody zamiast tworzyć nową instancję za każdym razem. W moim przypadku używałem do wyświetlania postępu i (info/error) wiadomości z Backroundworker kopiowania i odlewania dużych danych z instancji sql. Co jakiś czas po około 70000 postępach i komunikatach mój formularz przestał działać i pokazywał nowe wiadomości. Nie miało to miejsca, gdy zacząłem używać pojedynczego delegata instancji globalnej.

delegate void ShowMessageCallback(string message);

private void Form1_Load(object sender, EventArgs e)
{
    ShowMessageCallback showMessageDelegate = new ShowMessageCallback(ShowMessage);
}

private void ShowMessage(string message)
{
    if (this.InvokeRequired)
        this.Invoke(showMessageDelegate, message);
    else
        labelMessage.Text = message;           
}

void Message_OnMessage(object sender, Utilities.Message.MessageEventArgs e)
{
    ShowMessage(e.Message);
}

Użycie:

control.InvokeIfRequired(c => c.Visible = false);

return control.InvokeIfRequired(c => {
    c.Visible = value

    return c.Visible;
});

Kod:

using System;
using System.ComponentModel;

namespace Extensions
{
    public static class SynchronizeInvokeExtensions
    {
        public static void InvokeIfRequired<T>(this T obj, Action<T> action)
            where T : ISynchronizeInvoke
        {
            if (obj.InvokeRequired)
            {
                obj.Invoke(action, new object[] { obj });
            }
            else
            {
                action(obj);
            }
        }

        public static TOut InvokeIfRequired<TIn, TOut>(this TIn obj, Func<TIn, TOut> func) 
            where TIn : ISynchronizeInvoke
        {
            return obj.InvokeRequired
                ? (TOut)obj.Invoke(func, new object[] { obj })
                : func(obj);
        }
    }
}

Lubię robić to trochę inaczej, lubię nazywać się" sobą " w razie potrzeby za pomocą akcji,

    private void AddRowToListView(ScannerRow row, bool suspend)
    {
        if (IsFormClosing)
            return;

        if (this.InvokeRequired)
        {
            var A = new Action(() => AddRowToListView(row, suspend));
            this.Invoke(A);
            return;
        }
         //as of here the Code is thread-safe

Jest to poręczny wzorzec, pole IsFormClosing jest polem, które ustawiam na True, gdy zamykam formularz, ponieważ mogą istnieć wątki tła, które nadal działają...

Nigdy nie powinieneś pisać kodu, który wygląda tak:

private void DoGUISwitch() {
    if (object1.InvokeRequired) {
        object1.Invoke(new MethodInvoker(() => { DoGUISwitch(); }));
    } else {
        object1.Visible = true;
        object2.Visible = false;
    }
}

Jeśli masz kod, który wygląda tak, to Twoja aplikacja nie jest bezpieczna dla wątków. Oznacza to, że masz kod, który już wywołuje DoGUISwitch () z innego wątku. Za późno, żeby sprawdzić, czy jest w innym wątku. InvokeRequire musi zostać wywołany, zanim zadzwonisz do DoGUISwitch. Nie należy uzyskiwać dostępu do żadnej metody lub właściwości z innego wątku.

Odniesienie: Kontrola.InvokeRequired Property gdzie można przeczytać:

Oprócz właściwości InvokeRequired, istnieją cztery metody na kontrolka, która jest Bezpieczna do wywołania: Invoke, BeginInvoke, EndInvoke i CreateGraphics jeśli uchwyt do sterowania został już stworzony.

W jednej architekturze procesora nie ma problemu, ale w architekturze wielu procesorów można spowodować przypisanie części wątku interfejsu do procesora, gdzie kod był uruchomiony...a jeśli ten procesor jest inny od tego, gdzie działał wątek UI, to po zakończeniu wątku wywołującego Windows pomyśli, że wątek UI się zakończył i zabije proces aplikacji, tzn. Twoja aplikacja zakończy się bez błędu.