Вызов (делегат)

Ответ на этот вопрос заключается в том, как работают элементы управления C #.

Элементы управления в Windows Forms привязаны к определенному потоку и не являются потокобезопасными. Следовательно, если вы вызываете метод элемента управления из другого потока, вы должны использовать один из методов вызова элемента управления для маршалинга вызова в соответствующий поток. Это свойство можно использовать, чтобы определить, нужно ли вызывать метод invoke, что может быть полезно, если вы не знаете, какой поток владеет элементом управления.

Из Control. InvokeRequired

По сути, Invoke гарантирует, что вызываемый вами код выполняется в потоке, в котором «живет» элемент управления, эффективно предотвращая перекрестные исключения.

С исторической точки зрения в .Net 1.1 это действительно было разрешено. Это означало, что вы можете попробовать выполнить код в потоке «GUI» из любого фонового потока, и это в основном сработает. Иногда это просто приводило к завершению вашего приложения, потому что вы фактически прерывали поток графического интерфейса пользователя, пока он делал что-то еще. Это исключение Cross Threaded Exception - представьте, что вы пытаетесь обновить TextBox, пока графический интерфейс рисует что-то еще.

• Какое действие имеет приоритет?
• Возможно ли, чтобы и то и другое произошло одновременно?
• Что происходит со всеми другими командами, которые необходимо запустить графическому интерфейсу?

Фактически, вы прерываете очередь, что может иметь множество непредвиденных последствий. Invoke - это, по сути, «вежливый» способ поместить то, что вы хотите сделать в эту очередь, и это правило применялось начиная с .Net 2.0 и далее через брошенный InvalidOperationException.

Чтобы понять, что на самом деле происходит за кулисами и что подразумевается под «потоком графического интерфейса», полезно понять, что такое Message Pump или Message Loop.

Фактически, на этот вопрос уже есть ответ в вопросе «Что такое насос сообщений», и он рекомендуется. прочтите, чтобы понять реальный механизм, с которым вы связаны при взаимодействии с элементами управления.

Другое чтение, которое может оказаться полезным, включает:

Что случилось с Begin Invoke

Одно из основных правил программирования графического интерфейса Windows состоит в том, что только поток, создавший элемент управления, может получить доступ и / или изменить его содержимое (за исключением нескольких задокументированных исключений). Попробуйте сделать это из любого другого потока, и вы получите непредсказуемое поведение - от тупика до исключений и наполовину обновленного пользовательского интерфейса. Правильный способ обновить элемент управления из другого потока - отправить соответствующее сообщение в очередь сообщений приложения. Когда насос сообщений приступает к выполнению этого сообщения, элемент управления обновляется в том же потоке, который его создал (помните, насос сообщений работает в основном потоке).

и, для более подробного обзора кода с репрезентативной выборкой:

Недействительные межпоточные операции

// the canonical form (C# consumer)

public delegate void ControlStringConsumer(Control control, string text);  // defines a delegate type

public void SetText(Control control, string text) {
    if (control.InvokeRequired) {
        control.Invoke(new ControlStringConsumer(SetText), new object[]{control, text});  // invoking itself
    } else {
        control.Text=text;      // the "functional part", executing only on the main thread
    }
}

Когда вы оцените InvokeRequired, вы можете рассмотреть возможность использования метода расширения для упаковки этих вызовов. Это подробно описано в вопросе о переполнении стека Требуется очистка кода, помеченного с помощью Invoke .

Существует также дополнительная история исторического развития, которая может представлять интерес.

Элемент управления или объект окна в Windows Forms - это просто оболочка вокруг окна Win32, идентифицируемого дескриптором (иногда называемым HWND). Большинство действий, которые вы делаете с элементом управления, в конечном итоге приведет к вызову Win32 API, который использует этот дескриптор. Дескриптор принадлежит потоку, который его создал (обычно главному потоку), и не должен управляться другим потоком. Если по какой-то причине вам нужно что-то сделать с элементом управления из другого потока, вы можете использовать Invoke, чтобы попросить основной поток сделать это от вашего имени.

Например, если вы хотите изменить текст метки из рабочего потока, вы можете сделать что-то вроде этого:

theLabel.Invoke(new Action(() => theLabel.Text = "hello world from worker thread!"));

Если вы хотите изменить элемент управления, это необходимо сделать в потоке, в котором этот элемент управления был создан. Этот Invoke метод позволяет вам выполнять методы в связанном потоке (потоке, которому принадлежит базовый дескриптор окна элемента управления).

В приведенном ниже примере thread1 выдает исключение, потому что SetText1 пытается изменить textBox1.Text из другого потока. Но в thread2 действие в SetText2 выполняется в потоке, в котором был создан TextBox.

private void btn_Click(object sender, EvenetArgs e)
{
    var thread1 = new Thread(SetText1);
    var thread2 = new Thread(SetText2);
    thread1.Start();
    thread2.Start();
}

private void SetText1() 
{
    textBox1.Text = "Test";
}

private void SetText2() 
{
    textBox1.Invoke(new Action(() => textBox1.Text = "Test"));
}

На практике это означает, что делегат гарантированно будет вызван в основном потоке. Это важно, потому что в случае элементов управления Windows, если вы не обновляете их свойства в основном потоке, вы либо не видите изменения, либо элемент управления вызывает исключение.

Шаблон такой:

void OnEvent(object sender, EventArgs e)
{
   if (this.InvokeRequired)
   {
       this.Invoke(() => this.OnEvent(sender, e);
       return;
   }

   // do stuff (now you know you are on the main thread)
}

this.Invoke(delegate) убедитесь, что вы вызываете делегата аргументом this.Invoke() в основном потоке / созданном потоке.

Я могу сказать, что правило Thumb не имеет доступа к элементам управления вашей формы, кроме как из основного потока.

Возможно, следующие строки имеют смысл использовать Invoke ()

    private void SetText(string text)
    {
        // InvokeRequired required compares the thread ID of the
        // calling thread to the thread ID of the creating thread.
        // If these threads are different, it returns true.
        if (this.textBox1.InvokeRequired)
        {   
            SetTextCallback d = new SetTextCallback(SetText);
            this.Invoke(d, new object[] { text });
        }
        else
        {
            this.textBox1.Text = text;
        }
    }

Бывают ситуации, когда вы создаете поток Threadpool (т. Е. Рабочий поток), он будет работать в основном потоке. Он не будет создавать новый поток, потому что основной поток доступен для обработки дальнейших инструкций. Итак, сначала выясните, является ли текущий выполняющийся поток основным потоком, используя this.InvokeRequired, если возвращает true, текущий код выполняется в рабочем потоке, поэтому вызовите this.Invoke (d, new object [] {text});

иначе напрямую обновите элемент управления пользовательского интерфейса (здесь вы гарантированно запускаете код в основном потоке.)

Это означает, что делегат будет работать в потоке пользовательского интерфейса, даже если вы вызываете этот метод из фонового рабочего или потока пула потоков. Элементы пользовательского интерфейса имеют сходство с потоками - им нравится обращаться напрямую только к одному потоку: потоку пользовательского интерфейса. Поток пользовательского интерфейса определяется как поток, создавший экземпляр элемента управления, и поэтому связан с дескриптором окна. Но все это детали реализации.

Ключевой момент: вы должны вызвать этот метод из рабочего потока, чтобы получить доступ к пользовательскому интерфейсу (для изменения значения в метке и т. Д.), Поскольку вам запрещено , чтобы сделать это из любого другого потока, кроме потока пользовательского интерфейса.