How to: Make Thread-Safe Calls to Windows Forms Controls

最新推荐文章于 2024-10-30 22:31:58 发布
最新推荐文章于 2024-10-30 22:31:58 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： Interview & Program Life 文章标签： forms windows textbox thread asynchronous object

 

If you use multithreading to improve the performance of your Windows Forms applications, you must make sure that you make calls to your controls in a thread-safe way.

Access to Windows Forms controls is not inherently thread safe. If you have two or more threads manipulating the state of a control, it is possible to force the control into an inconsistent state. Other thread-related bugs are possible, such as race conditions and deadlocks. It is important to make sure that access to your controls is performed in a thread-safe way.

It is unsafe to call a control from a thread other than the one that created the control without using the Invoke method. The following is an example of a call that is not thread safe.

C#
Copy Code 
// This event handler creates a background thread that 
// attempts to set a Windows Forms control property 
// directly.
private void setTextUnsafeBtn_Click
    (object sender, EventArgs e)
{
    // Create a background thread and start it.
    this.demoThread =
        new Thread(new ThreadStart(this.ThreadProcUnsafe));
    this.demoThread.Start();

    // Continue in the main thread.  Set a textbox value that
    // would be overwritten by demoThread if it succeeded.
    // This value will appear immediately, then two seconds 
    // later the background thread will try to make its
    // change to the textbox.
    textBox1.Text = "Written by the main thread.";
}

// This method is executed on the worker thread. It attempts
// to access the TextBox control directly, which is not safe.
private void ThreadProcUnsafe()
{
    // Wait two seconds to simulate some background work
    // being done.
    Thread.Sleep(2000);

    this.textBox1.Text = 
        "Written unsafely by the background thread.";
}

The .NET Framework helps you detect when you are accessing your controls in a manner that is not thread safe. When you are running your application in the debugger, and a thread other than the one which created a control tries to call that control, the debugger raises an InvalidOperationException with the message, "Control control name accessed from a thread other than the thread it was created on."

This exception occurs reliably during debugging and, under some circumstances, at run time. You might see this exception when you debug applications that you wrote with the .NET Framework prior to the .NET Framework version 2.0. You are strongly advised to fix this problem when you see it, but you can disable it by setting the CheckForIllegalCrossThreadCalls property to false. This causes your control to run like it would run under Visual Studio .NET 2003 and the .NET Framework 1.1.

NoteNote:

If you are using ActiveX controls on a form, you may receive the cross-thread InvalidOperationException when you run under the debugger. When this occurs, the ActiveX control does not support multithreading. For more information about using ActiveX controls with Windows Forms, see Windows Forms and Unmanaged Applications. If you are using Visual Studio, you can prevent this exception by disabling the Visual Studio hosting process. For more information, see How to: Disable the Hosting Process.

 Making Thread-Safe Calls to Windows Forms Controls

To make a thread-safe call to a Windows Forms control

  1. Query the control's InvokeRequired property.

  2. If InvokeRequired returns true, call Invoke with a delegate that makes the actual call to the control.

  3. If InvokeRequired returns false, call the control directly.

In the following code example, a thread-safe call is implemented in the ThreadProcSafe method, which is executed by the background thread. If the TextBox control's InvokeRequired returns true, the ThreadProcSafe method creates an instance of SetTextCallback and passes that to the form's Invoke method. This causes the SetText method to be called on the thread that created the TextBox control, and in this thread context the Text property is set directly.

C#
Copy Code 
// This event handler creates a thread that calls a 
// Windows Forms control in a thread-safe way.
private void setTextSafeBtn_Click(
    object sender,
    EventArgs e)
{
    // Create a background thread and start it.
    this.demoThread =
        new Thread(new ThreadStart(this.ThreadProcSafe));
    this.demoThread.Start();

    // Continue in the main thread.  Set a textbox value
    // that will be overwritten by demoThread.
    textBox1.Text = "Written by the main thread.";
}

// If the calling thread is different from the thread that
// created the TextBox control, this method passes in the
// the SetText method to the SetTextCallback delegate and 
// passes in the delegate to the Invoke method.
private void ThreadProcSafe()
{
    // Wait two seconds to simulate some background work
    // being done.
    Thread.Sleep(2000);

    string text = "Written by the background thread.";
    // Check if this method is running on a different thread
    // than the thread that created the control.
    if (this.textBox1.InvokeRequired)
    {
        // It's on a different thread, so use Invoke.
        SetTextCallback d = new SetTextCallback(SetText);
        this.Invoke
            (d, new object[] { text + " (Invoke)" });
    }
    else
    {
        // It's on the same thread, no need for Invoke
        this.textBox1.Text = text + " (No Invoke)";
    }
}
C#
Copy Code 
// This method is passed in to the SetTextCallBack delegate
// to set the Text property of textBox1.
private void SetText(string text)
{
    this.textBox1.Text = text;
}
 Making Thread-Safe Calls by using BackgroundWorker

The preferred way to implement multithreading in your application is to use the BackgroundWorker component. The BackgroundWorker component uses an event-driven model for multithreading. The background thread runs your DoWork event handler, and the thread that creates your controls runs your ProgressChanged and RunWorkerCompleted event handlers. You can call your controls from your ProgressChanged and RunWorkerCompleted event handlers.

To make thread-safe calls by using BackgroundWorker

  1. Create a method to do the work that you want done in the background thread. Do not call controls created by the main thread in this method.

  2. Create a method to report the results of your background work after it finishes. You can call controls created by the main thread in this method.

  3. Bind the method created in step 1 to the DoWork event of an instance of BackgroundWorker, and bind the method created in step 2 to the same instance’s RunWorkerCompleted event.

  4. To start the background thread, call the RunWorkerAsync method of the BackgroundWorker instance.

In the following code example, the DoWork event handler uses Sleep to simulate work that takes some time. It does not call the form’s TextBox control. The TextBox control's Text property is set directly in the RunWorkerCompleted event handler.

C#
Copy Code 
// This BackgroundWorker is used to demonstrate the 
// preferred way of performing asynchronous operations.
private BackgroundWorker backgroundWorker1;
C#
Copy Code 
// This method starts BackgroundWorker by calling 
// RunWorkerAsync.  The Text property of the TextBox control
// is set by a method running in the main thread
// when BackgroundWorker raises the RunWorkerCompleted event.
private void setTextBackgroundWorkerBtn_Click(
    object sender,
    EventArgs e)
{
    this.backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
    this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted);
    this.backgroundWorker1.RunWorkerAsync();

    // Continue in the main thread.
    textBox1.Text = "Written by the main thread.";
}

// This method does the work you want done in the background.
void backgroundWorker1_DoWork (object sender, DoWorkEventArgs e)
{
    // Wait two seconds to simulate some background work
    // being done.
    Thread.Sleep(2000);

    // You could use the same technique as in the 
    // ThreadProcSafe method to set textBox1.Text here, but 
    // the preferred method is to do it from the Completed 
    // event handler which runs in the same thread as the one
    // that created the control.
}

// This method is called by BackgroundWorker's 
// RunWorkerCompleted event.  Because it runs in the
// main thread, it can safely set textBox1.Text.
private void backgroundWorker1_RunWorkerCompleted(
    object sender,
    RunWorkerCompletedEventArgs e)
{
    this.textBox1.Text =
        "Written by the main thread after the background thread completed.";
}

You can also report the progress of a background task by using the ProgressChanged event. For an example that incorporates that event, see BackgroundWorker.

 Example

The following code example is a complete Windows Forms application that consists of a form with three buttons and one text box. The first button demonstrates unsafe cross-thread access, the second button demonstrates safe access by using Invoke, and the third button demonstrates safe access by using BackgroundWorker.

NoteNote:

For instructions on how to run the example, see How to: Compile and Run a Complete Windows Forms Code Example Using Visual Studio. This example requires references to the System.Drawing and System.Windows.Forms assemblies.

C#
Copy Code 
using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

namespace CrossThreadDemo
{
    public class Form1 : Form
    {
        // This delegate enables asynchronous calls for setting
        // the text property on a TextBox control.
        delegate void SetTextCallback(string text);

        // This thread is used to demonstrate both thread-safe and
        // unsafe ways to call a Windows Forms control.
        private Thread demoThread = null;

        // This BackgroundWorker is used to demonstrate the 
        // preferred way of performing asynchronous operations.
        private BackgroundWorker backgroundWorker1;

        private TextBox textBox1;
        private Button setTextUnsafeBtn;
        private Button setTextSafeBtn;
        private Button setTextBackgroundWorkerBtn;

        private System.ComponentModel.IContainer components = null;

        public Form1()
        {
            InitializeComponent();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        // This event handler creates a background thread that 
        // attempts to set a Windows Forms control property 
        // directly.
        private void setTextUnsafeBtn_Click
            (object sender, EventArgs e)
        {
            // Create a background thread and start it.
            this.demoThread =
                new Thread(new ThreadStart(this.ThreadProcUnsafe));
            this.demoThread.Start();

            // Continue in the main thread.  Set a textbox value that
            // would be overwritten by demoThread if it succeeded.
            // This value will appear immediately, then two seconds 
            // later the background thread will try to make its
            // change to the textbox.
            textBox1.Text = "Written by the main thread.";
        }

        // This method is executed on the worker thread. It attempts
        // to access the TextBox control directly, which is not safe.
        private void ThreadProcUnsafe()
        {
            // Wait two seconds to simulate some background work
            // being done.
            Thread.Sleep(2000);

            this.textBox1.Text = 
                "Written unsafely by the background thread.";
        }

        // This event handler creates a thread that calls a 
        // Windows Forms control in a thread-safe way.
        private void setTextSafeBtn_Click(
            object sender,
            EventArgs e)
        {
            // Create a background thread and start it.
            this.demoThread =
                new Thread(new ThreadStart(this.ThreadProcSafe));
            this.demoThread.Start();

            // Continue in the main thread.  Set a textbox value
            // that will be overwritten by demoThread.
            textBox1.Text = "Written by the main thread.";
        }

        // If the calling thread is different from the thread that
        // created the TextBox control, this method passes in the
        // the SetText method to the SetTextCallback delegate and 
        // passes in the delegate to the Invoke method.
        private void ThreadProcSafe()
        {
            // Wait two seconds to simulate some background work
            // being done.
            Thread.Sleep(2000);

            string text = "Written by the background thread.";
            // Check if this method is running on a different thread
            // than the thread that created the control.
            if (this.textBox1.InvokeRequired)
            {
                // It's on a different thread, so use Invoke.
                SetTextCallback d = new SetTextCallback(SetText);
                this.Invoke
                    (d, new object[] { text + " (Invoke)" });
            }
            else
            {
                // It's on the same thread, no need for Invoke
                this.textBox1.Text = text + " (No Invoke)";
            }
        }

        // This method is passed in to the SetTextCallBack delegate
        // to set the Text property of textBox1.
        private void SetText(string text)
        {
            this.textBox1.Text = text;
        }

        // This method starts BackgroundWorker by calling 
        // RunWorkerAsync.  The Text property of the TextBox control
        // is set by a method running in the main thread
        // when BackgroundWorker raises the RunWorkerCompleted event.
        private void setTextBackgroundWorkerBtn_Click(
            object sender,
            EventArgs e)
        {
            this.backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
            this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted);
            this.backgroundWorker1.RunWorkerAsync();

            // Continue in the main thread.
            textBox1.Text = "Written by the main thread.";
        }

        // This method does the work you want done in the background.
        void backgroundWorker1_DoWork (object sender, DoWorkEventArgs e)
        {
            // Wait two seconds to simulate some background work
            // being done.
            Thread.Sleep(2000);

            // You could use the same technique as in the 
            // ThreadProcSafe method to set textBox1.Text here, but 
            // the preferred method is to do it from the Completed 
            // event handler which runs in the same thread as the one
            // that created the control.
        }

        // This method is called by BackgroundWorker's 
        // RunWorkerCompleted event.  Because it runs in the
        // main thread, it can safely set textBox1.Text.
        private void backgroundWorker1_RunWorkerCompleted(
            object sender,
            RunWorkerCompletedEventArgs e)
        {
            this.textBox1.Text =
                "Written by the main thread after the background thread completed.";
        }

        #region Windows Form Designer generated code

        private void InitializeComponent()
        {
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.setTextUnsafeBtn = new System.Windows.Forms.Button();
            this.setTextSafeBtn = new System.Windows.Forms.Button();
            this.setTextBackgroundWorkerBtn = new System.Windows.Forms.Button();
            this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
            this.SuspendLayout();
            // 
            // textBox1
            // 
            this.textBox1.Location = new System.Drawing.Point(12, 12);
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(360, 20);
            this.textBox1.TabIndex = 0;
            // 
            // setTextUnsafeBtn
            // 
            this.setTextUnsafeBtn.Location = new System.Drawing.Point(15, 55);
            this.setTextUnsafeBtn.Name = "setTextUnsafeBtn";
            this.setTextUnsafeBtn.TabIndex = 1;
            this.setTextUnsafeBtn.Text = "Unsafe Call";
            this.setTextUnsafeBtn.Click += new System.EventHandler(this.setTextUnsafeBtn_Click);
            // 
            // setTextSafeBtn
            // 
            this.setTextSafeBtn.Location = new System.Drawing.Point(96, 55);
            this.setTextSafeBtn.Name = "setTextSafeBtn";
            this.setTextSafeBtn.TabIndex = 2;
            this.setTextSafeBtn.Text = "Safe Call";
            this.setTextSafeBtn.Click += new System.EventHandler(this.setTextSafeBtn_Click);
            // 
            // setTextBackgroundWorkerBtn
            // 
            this.setTextBackgroundWorkerBtn.Location = new System.Drawing.Point(177, 55);
            this.setTextBackgroundWorkerBtn.Name = "setTextBackgroundWorkerBtn";
            this.setTextBackgroundWorkerBtn.TabIndex = 3;
            this.setTextBackgroundWorkerBtn.Text = "Safe BW Call";
            this.setTextBackgroundWorkerBtn.Click += new System.EventHandler(this.setTextBackgroundWorkerBtn_Click);
            // 
            // Form1
            // 
            this.ClientSize = new System.Drawing.Size(388, 96);
            this.Controls.Add(this.setTextBackgroundWorkerBtn);
            this.Controls.Add(this.setTextSafeBtn);
            this.Controls.Add(this.setTextUnsafeBtn);
            this.Controls.Add(this.textBox1);
            this.Name = "Form1";
            this.Text = "Form1";
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion


        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }

    }
}

When you run the application and click the Unsafe Call button, you immediately see "Written by the main thread" in the text box. Two seconds later, when the unsafe call is attempted, the Visual Studio debugger indicates that an exception occurred. The debugger stops at the line in the background thread that attempted to write directly to the text box. You will have to restart the application to test the other two buttons. When you click the Safe Call button, "Written by the main thread" appears in the text box. Two seconds later, the text box is set to "Written by the background thread (Invoke)", which indicates that the Invoke method was called. When you click the Safe BW Call button, "Written by the main thread" appears in the text box. Two seconds later, the text box is set to "Written by the main thread after the background thread completed", which indicates that the handler for the RunWorkerCompleted event of BackgroundWorker was called.

 Robust Programming
Caution noteCaution:

When you use multithreading of any sort, your code can be exposed to very serious and complex bugs. For more information, see Managed Threading Best Practices before you implement any solution that uses multithreading.

 See Also
Tasks
How to: Run an Operation in the Background
How to: Implement a Form That Uses a Background Operation
Reference
BackgroundWorker
Other Resources
Developing Custom Windows Forms Controls with the .NET Framework
Windows Forms and Unmanaged Applications
【reprinted from http://msdn.microsoft.com/en-us/library/ms171728.aspx】
****************************solution 2*******************************************
当然，你也可以忽略InvalidOperationException，在非调试的状态下，该异常并不会被抛出，CLR-Debugger监测对Handle的可能存在的不一致地存取，而期望达到更稳健(robust)的代码，这也就是Cross-thread operation not valid后的真正动机。
但是，放在面前的选择有二：第一，在某些情况下，我们并不需要这种善意的‘建议‘，而这种建议将在调试时带来了不必要的麻烦；第二，顺应善意的‘建议‘， 这也意味着我们必须调整已往行之有效且得心应手的编程模型(成本之一)，而这种调整额外还会带来side-effect，而这种side-effect目 前，我并不知道有什么简洁优雅的解决之道予以消除(成本之二)。
忽略Cross-thread InvalidOperationException建议，前提假设是我们不需要类似的建议，同时也不想给自己的调试带来过多的麻烦。
关闭CheckForIllegalCrossThreadCalls，这是Control class上的一个static property，默认值为flase，目的在于开关是否对Handle的可能存在的不一致存取的监测；且该项设置是具有Application scope的。
如果，只需要在某些Form中消除Cross-thread InvalidOperationException建议，可以在Form的.ctor中，InitializeComponent语句后将CheckForIllegalCrossThreadCalls设置为false 。
Code 2. - 1
public  Form1() {
    InitializeComponent();
    Control.CheckForIllegalCrossThreadCalls = false;
}
这种方式虽然可以达到忽略Cross-thread InvalidOperationException建议的目的，但代码不能明晰的表达具有Application scope的语义，下面方式能更好的表达Application scope语义而且便于维护。
Code 2. - 2
static  void Main() {
    Application.EnableVisualStyles();
Application .SetCompatibleTextRenderingDefault( false );
Control .CheckForIllegalCrossThreadCalls = false;
    Application.Run( new Form1() );

 

************************************solution 3(类一)*******************************************

 

Alternatively you can employ delegation to cross the thread boundary.  Here's an example of using a delegate to add an item to a ListBox: 
private delegate void AddListBoxItemDelegate(object item);

private void AddListBoxItem(object item)
{
    if (this.listBox1.InvokeRequired)
    {
        // This is a worker thread so delegate the task.
        this.listBox1.Invoke(new AddListBoxItemDelegate(this.AddListBoxItem), item);
    }
    else
    {
        // This is the UI thread so perform the task.
        this.listBox1.Items.Add(item);
    }
}

Now you can simply call the AddListBoxItem method from anywhere and it will handle the delegation itself if required

饅頭
关注
专栏目录
How-To Async Calls_How-ToAsyncCalls_
09-30
标题"如何进行异步调用_How-To Async Calls_"和描述中提到的"vb.net编程语言说明文件"以及"Visual Basic 2008 .NET"，都指向了这一主题。本篇将深入探讨异步编程在VB.NET中的应用，以及如何在Visual Basic 2008 .NET...
Cross-thread operation not valid
JoeM - Holy Joe's Blog CSDN Aggregation
12-18 5392
 Cross-thread operation not valid目录目录.. 2概要.. 31. Example. 31.1 Unsafe access to control31.2 What’s mean?. 42. The first choice : CheckForIllegalCrossThreadCalls. 43. The sec
C# Cross thread operation detected.
weixin_30328063的博客
07-30 1517
最近改别人的代码调试时报这个错，调试了蛮久没发现什么问题，百度了下也没发现相应的解决方案。 Thread th = new Thread(new ThreadStart(() => { table.Rows.Clear(); checkSaveData(); ...
IOS Dev Intro - Avoiding Common Networking Mistakes
fanbird2008的专栏
06-13 443
https://developer.apple.com/library/ios/documentation/NetworkingInternetWeb/Conceptual/NetworkingOverview/CommonPitfalls/CommonPitfalls.html Avoiding Common Networking Mistakes When wr
解决　vs2005编译错误提示 "how to make cross-thread calls"超简单实例
净心编程
03-04 1734
这两天在学习WebRequest Web Response对header操作时，涉及到异步操作，按实例运行出错，vs2005提示“how to make cross-thread calls...”，查了一下资料。将原来的代码google_ad_client = "pub-6924533005275861";google_ad_slot = "4211741364";google_
Oracle Solaris 11.1 man pages section2:System Calls-390
06-20
《Oracle Solaris 11.1 man pages section2:System Calls-390》是Oracle公司为Oracle Solaris 11.1操作系统提供的系统调用手册页，这部分主要涵盖了操作系统内核与应用程序交互的核心接口。系统调用是操作系统提供给...
Oracle Solaris 9 - man pages section 2: System Calls-552
07-29
Oracle Solaris 9 的 "man pages section 2: System Calls-552" 是一份关于操作系统内核接口的重要文档，主要涵盖了Solaris系统调用的详细信息。系统调用是用户空间程序与操作系统内核交互的主要机制，它们提供了...
Oracle Solaris 9 - man pages section 2: System Calls-360
08-07
Oracle Solaris 9 - man pages section 2: System Calls-360 Oracle Solaris 9 是一个由 Sun Microsystems 开发的操作系统，其中包括了丰富的系统调用接口，用于提供给开发者和系统管理员来管理和维护系统。man ...
Oracle Solaris 9 man pages section 2: System Calls-358
07-04
Oracle Solaris 9 man pages section 2: System Calls-358 本文档是 Oracle Solaris 9 操作系统的 man 页面，涵盖了 System Calls 部分的 358 项命令。System Calls 是操作系统提供的一组基本功能，应用程序可以...
WinForm中Cross-thread operation not valid错误的解决方法
weixin_30699955的博客
04-26 298
前一阵子写个小程序，画了一个Form，类名叫MainForm，程序里面还有一个TimerProcessor类，用于对System.Timers.Timer类的实例操作，由于Timer是在新线程中处理OnElapsed事件，而在处理这个事件的方法中，会对MainForm类的控件进行操作，于是，Debug运行时，就出现了如下错误： 从Additional information来看，是因为在非F...
一些常见的SQL报错
u012120851的专栏
12-18 5万+
This section lists messages generated when SQL statements are parsed by the Oracle Server. Most, but not all, messages in this section indicate incorrect SQL syntax. For more information about SQL syn
程序员常见系统错误代码大全：1到15841
热门推荐
南北极之间
02-19 10万+
程序员常见系统错误代码大全：1到15841 提示：使用浏览器的Ctrl + F键盘组合来搜索错误代码。要么搜索错误消息本身，要么只搜索错误代码，例如“错误代码635”。 系统错误代码大全：1到15841 错误代码1：功能不正确。[ERROR_INVALID_FUNCTION（0x1）] 错误代码2：系统找不到指定的文件。[ERROR_FILE_NOT_FOUND（0...
[转]Article: Invalid cross-thread operations
weixin_34419321的博客
01-14 114
原文：http://www.perceler.com/articles1.php?art=crossthreads1 Article: Invalid cross-thread operations When a WinForms application uses some threads, the ThreadPool, a Bac...
list（c++）
qq_75271671的博客
10-30 1136
list是STL容器中的容器，且元素在容器中的位置是分散的并与大小无关。list的底层是双向链表，其优势是在任意位置插入和删除元素的时间复杂度为O(1)，但无法通过“下标[ ]”直接访问元素，需要通过从头（尾）遍历元素找到元素，多用于需要大量数据的插入和删除，且对数据的随机访问比较少。 二、list 的iterator的使用 三、list capacity 接口说明 empty 检测list是否为空，是返回true，否则返回false size
今日好题——单链表
最新发布
2301_80681378的博客
10-30 424
合并有序链表&约瑟夫问题
java异步多线程精讲和多种写法
sunsiny
10-30 1265
如果需要更细粒度的控制，也允许你指定自定义的线程池。你可以通过Executor参数来实现：ExecutorService executor = Executors.newFixedThreadPool(10);// 任务逻辑通过ForkJoinPool实现了高效的异步任务处理，利用工作窃取模型和任务分解策略来提高并行处理能力。它的设计使得开发者能够以非阻塞的方式编写异步代码，同时提供了丰富的API来处理任务结果和异常。通过合理使用，程序员可以显著提高应用程序的响应性和性能。功能性提供了比Future。
Windows消息列表
smartDMer的专栏
10-30 786
353. WM_DDE_ACK=WM_DDE_FIRST+4: 此消息通知一个DDE（动态数据交换）程序已收到并正在处理WM_DDE_POKE,WM_DDE_EXECUTE,WM_DDE_DATA,WM_DDE_ADVISE,WM_DDE_UNADVISE,orWM_DDE_INITIAT消息WM_DDE_DATA=WM_DDE_FIRST+5:一个DDE服354. 务程序提交此消息给DDE客户程序来传递个一数据项给客户或通知客户的一条可用数据项。所有 者应滚动剪贴板图象并更新滚动条的值；
How to make tmdq progress bar for multilprocess
10-25
Here's a simple example on how to do it: 1. **Install tqdm**: If you haven't installed `tqdm`, you can do so using pip: ``` pip install tqdm ``` 2. **Import necessary libraries**: ```python ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值