c# - 如何识别该表单正在使用数据服务

Question

我有一个使用 WCF 数据服务的 C# WinForms 应用程序，但我找不到知道应用程序是否正在对 Web 服务进行处理的方法。我曾尝试实现 IClientMessageInspector 等，但似乎不起作用。

当 Windows 窗体应用程序正在使用 Web 服务时，还有其他方法可以捕获吗？目的是在打开与服务的通信时显示“正在运行的进程”图标，然后在关闭时将其隐藏。

谢谢。

Answer 1

您应该在调用 WcfService 方法的地方添加事件，然后在 UI 层中侦听此事件。在此事件中使用自定义事件参数，您应该为使用 UI 层提供更多信息，例如枚举值 Connected、TransferStarted、TransferEnded、Closed...

我认为有两种主要可能的情况： Wcf 通信发生同步 - 您正在调用对象的一些包装器方法，这些方法使用 wcf 服务处理连接/请求/响应 - 在这种情况下，我认为这很简单，您在每次调用之前进行 UI 操作例如包装器

try
{
 WcfEx.IwcfS5ExtensionClient client = new IwcfS5ExtensionClient("MyEndpointConfigurationName");
 client.Open();
 if (client.State == CommunicationState.Opened)
 {
     //change UI to Connected
 }
 else
 {
     //change ui to Connection Error
 }
 Application.DoEvents();
 //Change UI to Transfering data
 Application.DoEvents();
 client.DoWork();
 //change UI to transfer done
 Application.DoEvents();
 client.Close();
 //change ui to Closed
}
catch (Exception e)
{
   //change ui to Comunication error
}

其次是如果 wcf 通信是异步的-我将在今天晚些时候添加更多复杂的示例编辑：异步工作和通知表单的示例

using System;
using System.ComponentModel;
using System.Threading;

using WcfEx;

public class MyForm : Form
{
    public MyForm()
    {
        WcfHandler WcfConnection = new WcfHandler();
        WcfConnection.ProgressChanged += WcfConnectionOnProgressChanged;
    }

    private delegate void WcfConnectionOnProgressChangedDelegate(object Sender, WcfHandler.ProgressChangedEventArgs EventArgs);

    private void WcfConnectionOnProgressChanged(object Sender, WcfHandler.ProgressChangedEventArgs EventArgs)
    {
        //multi thread synchronization check
        if (this.InvokeRequired)
        {
            object[] Parameters = new object[2];
            Parameters[0] = Sender;
            Parameters[1] = EventArgs;
            this.Invoke(new WcfConnectionOnProgressChangedDelegate(WcfConnectionOnProgressChanged), Parameters);
        }
        else
        {
            if (EventArgs == null)
                return;

            switch (EventArgs.StateValue)
            {
                case WcfHandler.ProgressChangedEventArgs.State.Started:
                    {
                        this.Text = "Starting connection...";
                        break;
                    }
                case WcfHandler.ProgressChangedEventArgs.State.Processing:
                    {
                        this.Text = "Downloading updates...";
                        break;
                    }
                case WcfHandler.ProgressChangedEventArgs.State.Finished:
                    {
                        this.Text = EventArgs.Succes ? "Update completed" : "Update failed";
                        break;
                    }
            }

            Application.DoEvents();
        }
    }


    public class WcfHandler
    {
        public class ProgressChangedEventArgs : EventArgs
        {
            public enum State : int
            {
                Started,
                Processing,
                Finished
            };

            public bool Succes { get; set; }
            public State StateValue { get; set; }
        }

        public delegate void ProgressChangedEventHandler(object sender, ProgressChangedEventArgs EventArgs);

        public event ProgressChangedEventHandler ProgressChanged;

        protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
        {
            if (ProgressChanged != null)
            {
                ProgressChanged(this, e);
            }
        }

        public void StartChecking()
        {
            BackgroundWorker bWorker = new BackgroundWorker();

            bWorker.DoWork += CheckStatesAsync;
            bWorker.RunWorkerCompleted += BWorkerOnRunWorkerCompleted;

            bWorker.RunWorkerAsync();
        }

        private void CheckStatesAsync(object sender, DoWorkEventArgs e)
        {
            while (true)
            {
                WcfEx.IwcfS5ExtensionClient client = new IwcfS5ExtensionClient("MyWcfBindingConfig");
                ProgressChangedEventArgs Controller = new ProgressChangedEventArgs();
                Controller.StateValue = ProgressChangedEventArgs.State.Started;
                Controller.Succes = true;

                this.OnProgressChanged(Controller);

                try
                {
                    client.Open();

                    Controller.StateValue = ProgressChangedEventArgs.State.Processing;
                    Controller.Succes = true;
                    this.OnProgressChanged(Controller);

                    //do some work
                }
                catch (Exception)
                {
                    this.OnProgressChanged(new ProgressChangedEventArgs()
                                               {
                                                   StateValue = ProgressChangedEventArgs.State.Finished,
                                                   Succes = false
                                               });
                }

                Thread.Sleep(8000);
            }
        }

        private void BWorkerOnRunWorkerCompleted(object Sender, RunWorkerCompletedEventArgs RunWorkerCompletedEventArgs)
        {
            ProgressChangedEventArgs Controller = new ProgressChangedEventArgs();
            Controller.StateValue = ProgressChangedEventArgs.State.Finished;
            Controller.Succes = true;
            this.OnProgressChanged(Controller);
        }
    }