Question

我正在编写一个连接处理程序（一个请求用户名和密码的对话框）。代码是一个显示对话框的处理程序。可以从一个线程调用此代码，因此如果Invoke()，我需要InvokeRequired。

在理想情况下，我可以使用Control初始化然后处理程序来执行InvokeRequired，但有时控件可能为空。可能吗？我怎么能实现代码？以下是否正确？

public class GuiCredentialsHandler
{
    // control used to invoke if needed
    private static Control mInvokeControl;

    /// <summary>
    /// Initialize a GetCredentials handler for current process.
    /// This method should be always called from the main thread, for
    /// a correctly handling for invokes (when the handler is called
    /// from a thread).
    /// </summary>
    /// <param name="parentControl">Application top form. 
    /// Can be null if unknown</param>
    public static void Initialize(Control parentControl)
    {
        if (parentControl != null)
        {
            mInvokeControl = parentControl;
        }
        else
        {
            mInvokeControl = new Control();
            // force to create window handle
            mInvokeControl.CreateControl();
        }
    }

    public static Credentials GetCredentials()
    {
        if (mInvokeControl.InvokeRequired)
        {
            return mInvokeControl.Invoke(
                new GetCredentialsDelegate(DoGetCredentials), null) 
                as Credentials;
        }
        else
        {
            return DoGetCredentials();
        }
    }

    private static Credentials DoGetCredentials()
    {
        // the code stuff goes here
    }

}

我的问题是：

如果我将空控件传递给InitializeMethod()
如果在UIThread中执行了Initialize（）方法，代码会在以后工作吗？
如果您无法控制InvokeRequired？

提前致谢

编辑：做了一些测试，我意识到如果我将null传递给Initialize()，控件就不会在UI线程中运行，所以InvokeRequired似乎返回false。总是。所以我的问题是，当我无法控制时，如何执行真正的（有效的）调用？

EDIT2 ：执行mInvokeControl.CreateControl()解决问题。

Answer 1

在该课程上实施ISynchronizeInvoke。这是一个例子：

public class GuiCredentialsHandler : ISynchronizeInvoke
{
        //....

        private readonly System.Threading.SynchronizationContext _currentContext = System.Threading.SynchronizationContext.Current;

        private readonly System.Threading.Thread _mainThread = System.Threading.Thread.CurrentThread;

        private readonly object _invokeLocker = new object();
        //....


        #region ISynchronizeInvoke Members

        public bool InvokeRequired
        {
            get
            {
                return System.Threading.Thread.CurrentThread.ManagedThreadId != this._mainThread.ManagedThreadId;
            }
        }

        /// <summary>
        /// This method is not supported!
        /// </summary>
        /// <param name="method"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        [Obsolete("This method is not supported!", true)]
        public IAsyncResult BeginInvoke(Delegate method, object[] args)
        {
            throw new NotSupportedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// This method is not supported!
        /// </summary>
        /// <param name="method"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        [Obsolete("This method is not supported!", true)]
        public object EndInvoke(IAsyncResult result)
        {
            throw new NotSupportedException("The method or operation is not implemented.");
        }

        public object Invoke(Delegate method, object[] args)
        {
            if (method == null)
            {
                throw new ArgumentNullException("method");
            }

            lock (_invokeLocker)
            {
                object objectToGet = null;

                SendOrPostCallback invoker = new SendOrPostCallback(
                delegate(object data)
                {
                    objectToGet = method.DynamicInvoke(args);
                });

                _currentContext.Send(new SendOrPostCallback(invoker), method.Target);

                return objectToGet;
            }
        }

        public object Invoke(Delegate method)
        {
            return Invoke(method, null);
        }

        #endregion//ISynchronizeInvoke Members

}

注意：由于类实现它使用System.Threading.SynchronizationContext.Current，因此您可以在WindowsForms或wpf中使用它，但不能在控制台应用程序中使用它，因为System.Threading.SynchronizationContext.Current为空。< / p>

Answer 2

一个简单的解决方案是在主线程中创建一个不可见的控件，工作线程可以在其上调用Invoke。

当我没有Control可用时如何调用（）

2 个答案: