Why am I allowed to upload an image to a stream without a GUI?

Question

It is well known that you cannot change the GUI with any other thread than the GUI thread. Therefore, a simple trick that is commonly used (which I use) is used:

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

I created my program and started it, quickly noticing that I forgot to put it PictureBox.Load(string url)in invoker, but there was no error.

So, I am curious why I am not allowed to do (in a non-GUI thread):

pictureBox1.Visible = false; // eg.

But I am allowed to do:

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

Answer 1

, , 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 .

    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 ).

Answer 2

, " ", , , Handle :

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

        if (!IsHandleCreated)
        {
            CreateHandle();
        }

        return HandleInternal;
    }
}

, SetVisibleCore ( ) Handle, InstallNewImage ( Load). (, Invalidate Handle, , .)