I started to write this WPF series. The one-stop style here is to strive to explain it at every point. Of course, I can't do it as well. If there is something wrong, I welcome friends to correct me. I will gradually add it. Try to write this series well.
Typically, a WPF application starts with two threads: one for processing the rendering and one for managing the UI. Render threads are effectively hidden from running in the background, while UI threads receive input, process events, draw screens, and run application code.
The UI thread queues work items within an object named Dispatcher. Dispatcher selects work items based on priority and runs each work item until it is completed. Every UI thread must have at least one Dispatcher, and each Dispatcher can only execute work items in one thread.
These two paragraphs are descriptions of the WPF threading model on MSDN. Mainly introduced two concepts: First, the thread in WPF is divided into two, one for rendering (Render), one for managing UI; Second, in the UI thread, using a class called Dispatcher to help UI thread processing task.
So what exactly is this threading model and Dispatcher? What are its characteristics, and what are the advantages and disadvantages? Before the formal analysis of the thread model and Dispatcher, I first find an insertion point, I hope this insertion point can be understood by friends.
As a base for PresentaTIon, WPF's mission is to write graphical user interfaces. On the Windows operating system, the graphical interface is based on the message mechanism. So what steps do you need to create a window?
1. Create a window class. WNDCLASSEX wcex; RegisterClassEx(&wcex);
2. Create a window. CreateWindow(...); ShowWindow(...); UpdateWindow(...);
3. Establish a message pump.
While (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
For example, we produce equipment in an automated factory. Based on the formal, we will first define the template of the device, this is to create a window class, where "class" more means the meaning of the category. After the template is defined, we can officially produce the device. This is the creation of the window. This CreateWindow will match the template we defined (the window class) with a string. After the creation is successful, we have to make the device move. It must be like a human. The body must have a blood-like circulation mechanism to communicate the commands to all parts of the device. This is the message pump. This pump is like our heart. , continuously through the GetMessage and Dispatch to distribute blood (message). Since we use the message to issue instructions to the device, then there must be a message queue to store the message. In Windows, the thread is the basic scheduling unit. This message queue is on the thread. When the GetMessage is used cyclically, it is in the current thread. The message queue is taken out of the message and then distributed to the corresponding window.
So specific to WPF, what kind of situation is it, how to be compatible with the old technology, and what new breakthroughs?
WPF introduces the concept of Dispatcher. The main function of this Dispatcher is similar to the message queue in Win32. In its internal function, it still calls the traditional creation of window class, creating window, establishing message pump and so on. Dispatcher itself is a singleton pattern, the constructor is private, and a static CurrentDispatcher method is exposed to get the Dispatcher of the current thread. For threads, it knows nothing about Dispatcher. Dispatcher internally maintains a static List _dispatchers. Whenever the CurrentDispatcher method is used, it will traverse in this _dispatchers. If it is not found, create a new one. Dispatcher object, added to _dispatchers. Dispatcher internally maintains a Thread property. When the Dispatcher is created, the current thread is assigned to the Thread property. The next time the traversal lookup is used, this field is used to match whether the current thread's Dispatcher has been saved in _dispatchers.
Then when is this creation window created when the message pump is called? Inside the Dispatcher, a HwndWrapper field is maintained. In the Dispatcher constructor, the HwndWrapper constructor is called. This creates the window class, which is called in this function. The actual class here is MessageOnlyHwndWrapper, this Message-Only, is a common trick in Windows programming, creating a hidden window that is only used to dispatch messages. Then when is the message pump that cyclically reads the message established?
Dispatcher provides a static Run function. As the name suggests, it starts the Dispatcher. Inside the function, the PushFrame function is called. In this function, you can find the familiar GetMessage, TranslateAndDispatchMessage. So what is this PushFrame, and how does the concept of Frame come from?
This is a new concept introduced by WPF. The nested message pump starts a While (GetMessage(...)) inside a While(GetMessage(..)). Each time a PushFrame is called, a new nested message pump is started. Each time GetMessage is called, a message is fetched in the thread's message queue until GetMessage returns False when WM_QUIT is fetched. This GetMessage function is internally handled by Windows. When the message queue is empty, the execution thread is suspended to avoid the occurrence of an infinite loop. Regarding the advantages and disadvantages of nested message pumps, let's talk about it later, let's first look at how Dispatcher handles tasks:
Wireless Earphones,Wireless Earbuds,Wireless Earphones With Mic,Wireless Bluetooth Earphones
Guangzhou YISON Electron Technology Co., Limited , https://www.yisonearphone.com