为什么我被允许在非gui线程中加载图像

本文关键字：线程 gui 加载 图像 为什么 | 更新日期: 2023-09-27 18:18:19

众所周知，您不能使用GUI线程以外的任何其他线程更改GUI。因此，一个常用的简单技巧(我使用)是调用:

this.Invoke((MethodInvoker)delegate { pictureBox1.Visible = false; });

我正在构建我的程序并启动它，很快注意到我忘记在调用程序中放入PictureBox.Load(string url)，但是没有发生错误。

所以我很好奇，为什么我不允许这样做(在非gui线程):

pictureBox1.Visible = false; // eg.

但是我可以这样做:

pictureBox1.Load(url); // url = link to image

为什么我被允许在非gui线程中加载图像

当您加载新图像时，PictureBox(这是从Load方法调用的)内部发生的情况如下:

    private void InstallNewImage(Image value,
                                 ImageInstallationType installationType)
    {
        StopAnimate();
        this.image = value;
        LayoutTransaction.DoLayoutIf(AutoSize, this, this, PropertyNames.Image); 
        Animate();
        if (installationType != ImageInstallationType.ErrorOrInitial)
        {
            AdjustSize();
        }
        this.imageInstallationType = installationType;
        Invalidate();
        CommonProperties.xClearPreferredSizeCache(this);
    }

所以你可以看到它真正做的是设置图像，然后调用Invalidate，这可以从其他线程调用。

Visible(继承自Control)，你可以在这里看到，通过p/invoke做很多事情，必须在主UI线程上完成。

    protected virtual void SetVisibleCore(bool value) {
        try {
            System.Internal.HandleCollector.SuspendCollect();
            if (GetVisibleCore() != value) {
                if (!value) {
                    SelectNextIfFocused();
                }
                bool fireChange = false;
                if (GetTopLevel()) {
                    // The processing of WmShowWindow will set the visibility
                    // bit and call CreateControl()
                    //
                    if (IsHandleCreated || value) {
                            SafeNativeMethods.ShowWindow(new HandleRef(this, Handle), value ? ShowParams : NativeMethods.SW_HIDE);
                    }
                }
                else if (IsHandleCreated || value && parent != null && parent.Created) {
                    // We want to mark the control as visible so that CreateControl
                    // knows that we are going to be displayed... however in case
                    // an exception is thrown, we need to back the change out.
                    //
                    SetState(STATE_VISIBLE, value);
                    fireChange = true;
                    try {
                        if (value) CreateControl();
                        SafeNativeMethods.SetWindowPos(new HandleRef(window, Handle),
                                                       NativeMethods.NullHandleRef,
                                                       0, 0, 0, 0,
                                                       NativeMethods.SWP_NOSIZE
                                                       | NativeMethods.SWP_NOMOVE
                                                       | NativeMethods.SWP_NOZORDER
                                                       | NativeMethods.SWP_NOACTIVATE
                                                       | (value ? NativeMethods.SWP_SHOWWINDOW : NativeMethods.SWP_HIDEWINDOW));
                    }
                    catch {
                        SetState(STATE_VISIBLE, !value);
                        throw;
                    }
                }
                if (GetVisibleCore() != value) {
                    SetState(STATE_VISIBLE, value);
                    fireChange = true;
                }
                if (fireChange) {
                    // We do not do this in the OnPropertyChanged event for visible
                    // Lots of things could cause us to become visible, including a
                    // parent window.  We do not want to indescriminiately layout
                    // due to this, but we do want to layout if the user changed
                    // our visibility.
                    //
                    using (new LayoutTransaction(parent, this, PropertyNames.Visible)) {
                        OnVisibleChanged(EventArgs.Empty);
                    }
                }
                UpdateRoot();
            }
            else { // value of Visible property not changed, but raw bit may have
                if (!GetState(STATE_VISIBLE) && !value && IsHandleCreated) {
                    // PERF - setting Visible=false twice can get us into this else block
                    // which makes us process WM_WINDOWPOS* messages - make sure we've already 
                    // visible=false - if not, make it so.
                     if (!SafeNativeMethods.IsWindowVisible(new HandleRef(this,this.Handle))) {
                        // we're already invisible - bail.
                        return;
                     }
                }
                SetState(STATE_VISIBLE, value);
                // If the handle is already created, we need to update the window style.
                // This situation occurs when the parent control is not currently visible,
                // but the child control has already been created.
                //
                if (IsHandleCreated) {
                    SafeNativeMethods.SetWindowPos(
                                                      new HandleRef(window, Handle), NativeMethods.NullHandleRef, 0, 0, 0, 0, NativeMethods.SWP_NOSIZE |
                                                      NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE |
                                                      (value ? NativeMethods.SWP_SHOWWINDOW : NativeMethods.SWP_HIDEWINDOW));
                }
            }
        }
        finally {
            System.Internal.HandleCollector.ResumeCollect();
        }
    }

作为一个边注，很多这些"幕后发生的事情"可以通过浏览参考源代码，或创建一个小应用程序并反编译来弄清楚(我推荐JetBrains DotPeek，或者ildasm也可以)。

没有得到"Cross-thread operation not valid"消息的原因是当control Handle属性被访问时抛出异常:

public IntPtr Handle {
    get {
        if (checkForIllegalCrossThreadCalls &&
            !inCrossThreadSafeCall &&
            InvokeRequired) {
            throw new InvalidOperationException(SR.GetString(SR.IllegalCrossThreadCall,
                                                             Name));
        }
        if (!IsHandleCreated)
        {
            CreateHandle();
        }
        return HandleInternal;
    }
}

从接受的应答中可以看出，SetVisibleCore(由Visible调用)多次使用Handle，而InstallNewImage(由Load调用)没有使用。(实际上，Invalidate确实访问Handle属性，但它在线程安全的调用范围内这样做是好的。)

相关文章：