【UWP】让 UWP 本身托管本身 —— Windows SDK 篇

众所周知，UWP 使用的窗口模型是 CoreWindow，但是 UWP 本身只是一个应用模型，所以完全可以创建 win32 窗口，那么我们可以不可以创建一个 win32 窗口，然后像 XAML 岛 (XAML Islands) 一样把 XAML 托管上去呢？本篇将讲述如安在 UWP 创建一个 XAML 岛窗口。

起首，XAML 岛会判断当前的应用模型是否为ClassicDesktop，所以我们需要利用Detours劫持AppPolicyGetWindowingModel方法。具体内容如下：

1. #r "nuget:Detours.Win32Metadata"
2. #r "nuget:Microsoft.Windows.CsWin32"
4. using System;
5. using System.Runtime.CompilerServices;
6. using System.Runtime.InteropServices;
7. using Windows.Win32;
8. using Windows.Win32.Foundation;
9. using Windows.Win32.Storage.Packaging.Appx;
10. using Detours = Microsoft.Detours.PInvoke;
12. /// <summary>
13. /// Represents a hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
14. /// </summary>
15. public sealed partial class HookWindowingModel : IDisposable
16. {
17.     /// <summary>
18.     /// The value that indicates whether the class has been disposed.
19.     /// </summary>
20.     private bool disposed;
22.     /// <summary>
23.     /// The reference count for the hook.
24.     /// </summary>
25.     private static int refCount;
27.     /// <summary>
28.     /// The value that represents the current process token.
29.     /// </summary>
30.     private const int currentProcessToken = -6;
32.     /// <remarks>The original <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.</remarks>
33.     /// <inheritdoc cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/>
34.     private static unsafe delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> AppPolicyGetWindowingModel;
36.     /// <summary>
37.     /// Initializes a new instance of the <see cref="HookWindowingModel"/> class.
38.     /// </summary>
39.     public HookWindowingModel()
40.     {
41.         refCount++;
42.         StartHook();
43.     }
45.     /// <summary>
46.     /// Finalizes this instance of the <see cref="HookWindowingModel"/> class.
47.     /// </summary>
48.     ~HookWindowingModel()
49.     {
50.         Dispose();
51.     }
53.     /// <summary>
54.     /// Gets the value that indicates whether the hook is active.
55.     /// </summary>
56.     public static bool IsHooked { get; private set; }
58.     /// <summary>
59.     /// Gets or sets the windowing model to use when the hooked <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function is called.
60.     /// </summary>
61.     internal static AppPolicyWindowingModel WindowingModel { get; set; } = AppPolicyWindowingModel.AppPolicyWindowingModel_ClassicDesktop;
63.     /// <summary>
64.     /// Starts the hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
65.     /// </summary>
66.     private static unsafe void StartHook()
67.     {
68.         if (!IsHooked)
69.         {
70.             using FreeLibrarySafeHandle library = PInvoke.GetModuleHandle("KERNEL32.dll");
71.             if (!library.IsInvalid && NativeLibrary.TryGetExport(library.DangerousGetHandle(), nameof(PInvoke.AppPolicyGetWindowingModel), out nint appPolicyGetWindowingModel))
72.             {
73.                 void* appPolicyGetWindowingModelPtr = (void*)appPolicyGetWindowingModel;
74.                 delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;
76.                 _ = Detours.DetourRestoreAfterWith();
78.                 _ = Detours.DetourTransactionBegin();
79.                 _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
80.                 _ = Detours.DetourAttach(ref appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
81.                 _ = Detours.DetourTransactionCommit();
83.                 AppPolicyGetWindowingModel = (delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR>)appPolicyGetWindowingModelPtr;
84.                 IsHooked = true;
85.             }
86.         }
87.     }
89.     /// <summary>
90.     /// Ends the hook for the <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.
91.     /// </summary>
92.     private static unsafe void EndHook()
93.     {
94.         if (--refCount == 0 && IsHooked)
95.         {
96.             void* appPolicyGetWindowingModelPtr = AppPolicyGetWindowingModel;
97.             delegate* unmanaged[Stdcall]<HANDLE, AppPolicyWindowingModel*, WIN32_ERROR> overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;
99.             _ = Detours.DetourTransactionBegin();
100.             _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
101.             _ = Detours.DetourDetach(&appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
102.             _ = Detours.DetourTransactionCommit();
104.             AppPolicyGetWindowingModel = null;
105.             IsHooked = false;
106.         }
107.     }
109.     /// <param name="policy">A pointer to a variable of the <a target="_blank" href="https://docs.microsoft.com/windows/win32/api/appmodel/ne-appmodel-apppolicywindowingmodel">AppPolicyWindowingModel</a> enumerated type.
110.     /// When the function returns successfully, the variable contains the <see cref="WindowingModel"/> when the identified process is current; otherwise, the windowing model of the identified process.</param>
111.     /// <remarks>The overridden <see cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/> function.</remarks>
112.     /// <inheritdoc cref="PInvoke.AppPolicyGetWindowingModel(HANDLE, AppPolicyWindowingModel*)"/>
113.     [UnmanagedCallersOnly(CallConvs = [typeof(CallConvStdcall)])]
114.     private static unsafe WIN32_ERROR OverrideAppPolicyGetWindowingModel(HANDLE processToken, AppPolicyWindowingModel* policy)
115.     {
116.         if ((int)processToken.Value == currentProcessToken)
117.         {
118.             *policy = WindowingModel;
119.             return WIN32_ERROR.ERROR_SUCCESS;
120.         }
121.         return AppPolicyGetWindowingModel(processToken, policy);
122.     }
124.     /// <inheritdoc/>
125.     public void Dispose()
126.     {
127.         if (!disposed && IsHooked)
128.         {
129.             EndHook();
130.         }
131.         GC.SuppressFinalize(this);
132.         disposed = true;
133.     }
134. }

复制代码

准备工作完成，接下来我们就可以创建窗口了，起首我们需要新创建一个线程，CoreWindow 线程无法新建 XAML 岛，新建线程只需要用Thread就行了。

1. new Thread(() => { ... });

复制代码

起首我们需要创建 XAML 岛，这时我们就需要利用上面劫持器来劫持获取应用模型的方法了。

1. DesktopWindowXamlSource source;
2. using (HookWindowingModel hook = new())
3. {
4.     source = new DesktopWindowXamlSource();
5. }

复制代码

微软并没有单独提供一个 Win32 窗口管理的轮子，如果引用 Windows Forms 就太臃肿了，于是我们需要手动制作一个 Window 类：

1. /// <summary>
2. /// Represents a system-managed container for the content of an app.
3. /// </summary>
4. public partial class DesktopWindow
5. {
6.     private bool m_bIsClosed = false;
7.     private DesktopWindowXamlSource m_source;
8.     private IDesktopWindowXamlSourceNative m_native;
10.     private readonly HWND m_hwnd;
11.     private readonly WNDCLASSEXW m_wndClassEx;
13.     /// <summary>
14.     /// Initializes a new instance of the <see cref="DesktopWindow"/> class.
15.     /// </summary>
16.     public DesktopWindow()
17.     {
18.         m_wndClassEx = RegisterDesktopWindowClass(WNDPROC);
19.         m_hwnd = CreateDesktopWindow();
20.     }
22.     /// <summary>
23.     /// Gets the event dispatcher for the window.
24.     /// </summary>
25.     public CoreDispatcher Dispatcher { get; private set; }
27.     /// <summary>
28.     /// Gets the <see cref="DesktopWindowXamlSource"/> to provide XAML for this window.
29.     /// </summary>
30.     public DesktopWindowXamlSource WindowXamlSource
31.     {
32.         get => m_source;
33.         private init
34.         {
35.             if (m_source != value)
36.             {
37.                 m_source = value;
38.                 if (value != null)
39.                 {
40.                     Dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
41.                     m_native = value.As<IDesktopWindowXamlSourceNative>();
42.                     m_native.AttachToWindow(m_hwnd);
43.                     ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
44.                 }
45.                 else
46.                 {
47.                     m_native = null;
48.                 }
49.             }
50.         }
51.     }
53.     /// <summary>
54.     /// Shows the window and activates it.
55.     /// </summary>
56.     public void Show() => _ = PInvoke.ShowWindow(m_hwnd, SHOW_WINDOW_CMD.SW_NORMAL);
58.     private LRESULT WNDPROC(HWND hWnd, uint message, WPARAM wParam, LPARAM lParam)
59.     {
60.         switch (message)
61.         {
62.             case PInvoke.WM_PAINT:
63.                 HDC hdc = PInvoke.BeginPaint(hWnd, out PAINTSTRUCT ps);
64.                 _ = PInvoke.GetClientRect(hWnd, out RECT rect);
65.                 _ = PInvoke.FillRect(hdc, rect, new DefaultSafeHandle(PInvoke.GetStockObject(GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH)));
66.                 _ = PInvoke.EndPaint(hWnd, ps);
67.                 return new LRESULT();
68.             case PInvoke.WM_CLOSE when m_bIsClosed:
69.                 goto default;
70.             case PInvoke.WM_CLOSE:
71.                 m_bIsClosed = true;
72.                 goto default;
73.             case PInvoke.WM_SIZE:
74.                 ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
75.                 return new LRESULT();
76.             case PInvoke.WM_CREATE:
77.                 return new LRESULT();
78.             case PInvoke.WM_DESTROY:
79.                 PInvoke.PostQuitMessage(0);
80.                 return new LRESULT();
81.             default:
82.                 return PInvoke.DefWindowProc(hWnd, message, wParam, lParam);
83.         }
84.     }
86.     private void ResizeWindowToDesktopWindowXamlSourceWindowDimensions()
87.     {
88.         if (m_bIsClosed) return;
89.         _ = PInvoke.GetClientRect(m_hwnd, out RECT rect);
90.         _ = PInvoke.SetWindowPos(
91.             m_native.WindowHandle,
92.             new HWND(),
93.             0, 0,
94.             rect.Width, rect.Height,
95.             SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW);
96.     }
97. }
99. public partial class DesktopWindow
100. {
101.     private static readonly unsafe HINSTANCE g_hInstance = new((void*)Process.GetCurrentProcess().Handle);
103.     // win32 window class name for top-level WinUI desktop windows
104.     private const string s_windowClassName = "WinUIDesktopWin32WindowClass";
106.     // Default window title for top-level WinUI desktop windows
107.     private const string s_defaultWindowTitle = "WinUI Desktop";
109.     private static unsafe WNDCLASSEXW RegisterDesktopWindowClass(WNDPROC lpfnWndProc)
110.     {
111.         if (!PInvoke.GetClassInfoEx(new DefaultSafeHandle(g_hInstance), s_windowClassName, out WNDCLASSEXW wndClassEx))
112.         {
113.             wndClassEx.cbSize = (uint)Marshal.SizeOf(wndClassEx);
114.             wndClassEx.style = WNDCLASS_STYLES.CS_HREDRAW | WNDCLASS_STYLES.CS_VREDRAW;
115.             wndClassEx.cbClsExtra = 0;
116.             wndClassEx.cbWndExtra = 0;
117.             wndClassEx.hCursor = PInvoke.LoadCursor(new HINSTANCE(), PInvoke.IDC_ARROW);
118.             wndClassEx.hbrBackground = (HBRUSH)((nint)SYS_COLOR_INDEX.COLOR_WINDOW + 1);
119.             wndClassEx.hInstance = g_hInstance;
121.             fixed (char* lps_windowClassName = s_windowClassName)
122.             {
123.                 wndClassEx.lpszClassName = lps_windowClassName;
124.             }
126.             wndClassEx.lpfnWndProc = lpfnWndProc;
127.             _ = PInvoke.RegisterClassEx(wndClassEx);
129.             return wndClassEx;
130.         }
131.         return default;
132.     }
134.     private static unsafe HWND CreateDesktopWindow() =>
135.         PInvoke.CreateWindowEx(
136.             0,                                  // Extended Style
137.             s_windowClassName,                  // name of window class
138.             s_defaultWindowTitle,               // title-bar string
139.             WINDOW_STYLE.WS_OVERLAPPEDWINDOW | WINDOW_STYLE.WS_VISIBLE,  // top-level window
140.             int.MinValue,                       // default horizontal position
141.             (int)SHOW_WINDOW_CMD.SW_HIDE,       // If the y parameter is some other value,
142.                                                 // then the window manager calls ShowWindow with that value as the nCmdShow parameter
143.             int.MinValue,                       // default width
144.             int.MinValue,                       // default height
145.             new HWND(),                         // no owner window
146.             null,                               // use class menu
147.             new DefaultSafeHandle(g_hInstance),
148.             null);
150.     private partial class DefaultSafeHandle(nint invalidHandleValue, bool ownsHandle) : SafeHandle(invalidHandleValue, ownsHandle)
151.     {
152.         public DefaultSafeHandle(nint handle) : this(handle, true) => SetHandle(handle);
154.         public override bool IsInvalid => handle != nint.Zero;
156.         protected override bool ReleaseHandle() => true;
157.     }
158. }

复制代码

然后我们就可以初始化一个窗口了。

1. DesktopWindow window = new() { WindowXamlSource = source };

复制代码

末了不要忘了用消息循环保持当火线程，不然这里跑完了窗口就退出了。

1. MSG msg = new();
2. while (msg.message != PInvoke.WM_QUIT)
3. {
4.     if (PInvoke.PeekMessage(out msg, new HWND(), 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
5.     {
6.         _ = PInvoke.DispatchMessage(msg);
7.     }
8. }

复制代码

末了把之前的东西组合起来，再加点东西：

1. /// <summary>
2. /// Represents a system-managed container for the content of an app.
3. /// </summary>
4. public partial class DesktopWindow
5. {
6.     private bool m_bIsClosed = false;
7.     private DesktopWindowXamlSource m_source;
8.     private IDesktopWindowXamlSourceNative m_native;
10.     private readonly HWND m_hwnd;
11.     private readonly WNDCLASSEXW m_wndClassEx;
13.     /// <summary>
14.     /// Initializes a new instance of the <see cref="DesktopWindow"/> class.
15.     /// </summary>
16.     public DesktopWindow()
17.     {
18.         m_wndClassEx = RegisterDesktopWindowClass(WNDPROC);
19.         m_hwnd = CreateDesktopWindow();
20.     }
22.     /// <summary>
23.     /// Get the handle of the window.
24.     /// </summary>
25.     public nint Hwnd => m_hwnd;
27.     /// <summary>
28.     /// Gets the event dispatcher for the window.
29.     /// </summary>
30.     public CoreDispatcher Dispatcher { get; private set; }
32.     /// <summary>
33.     /// Gets or sets the visual root of an application window.
34.     /// </summary>
35.     public UIElement Content
36.     {
37.         get => WindowXamlSource.Content;
38.         set => WindowXamlSource.Content = value;
39.     }
41.     /// <summary>
42.     /// Gets or sets the XamlRoot in which this element is being viewed.
43.     /// </summary>
44.     [SupportedOSPlatform("Windows10.0.18362.0")]
45.     public XamlRoot XamlRoot
46.     {
47.         get => WindowXamlSource.Content.XamlRoot;
48.         set => WindowXamlSource.Content.XamlRoot = value;
49.     }
51.     /// <summary>
52.     /// Gets or sets a string used for the window title.
53.     /// </summary>
54.     public unsafe string Title
55.     {
56.         get
57.         {
58.             int windowTextLength = PInvoke.GetWindowTextLength(m_hwnd);
59.             char* windowText = stackalloc char[windowTextLength + 1];
60.             _ = PInvoke.GetWindowText(m_hwnd, windowText, windowTextLength + 1);
61.             return new string(windowText);
62.         }
63.         set => _ = PInvoke.SetWindowText(m_hwnd, value);
64.     }
66.     /// <summary>
67.     /// Gets the <see cref="DesktopWindowXamlSource"/> to provide XAML for this window.
68.     /// </summary>
69.     public DesktopWindowXamlSource WindowXamlSource
70.     {
71.         get => m_source;
72.         private init
73.         {
74.             if (m_source != value)
75.             {
76.                 m_source = value;
77.                 if (value != null)
78.                 {
79.                     Dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
80.                     m_native = value.As<IDesktopWindowXamlSourceNative>();
81.                     m_native.AttachToWindow(m_hwnd);
82.                     ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
83.                 }
84.                 else
85.                 {
86.                     m_native = null;
87.                 }
88.             }
89.         }
90.     }
92.     /// <summary>
93.     /// Occurs when the window has closed.
94.     /// </summary>
95.     public event TypedEventHandler<DesktopWindow, object> Closed;
97.     /// <summary>
98.     /// Shows the window and activates it.
99.     /// </summary>
100.     public void Show() => _ = PInvoke.ShowWindow(m_hwnd, SHOW_WINDOW_CMD.SW_NORMAL);
102.     /// <summary>
103.     /// Sets the icon for the window, using the specified icon path.
104.     /// </summary>
105.     /// <param name="iconPath">The path of the icon.</param>
106.     public unsafe void SetIcon(string iconPath)
107.     {
108.         fixed (char* ptr = iconPath)
109.         {
110.             HANDLE icon = PInvoke.LoadImage(new HINSTANCE(), ptr, GDI_IMAGE_TYPE.IMAGE_ICON, 0, 0, IMAGE_FLAGS.LR_LOADFROMFILE);
111.             _ = PInvoke.SendMessage(m_hwnd, PInvoke.WM_SETICON, PInvoke.ICON_BIG, new LPARAM((nint)icon.Value));
112.         }
113.     }
115.     private LRESULT WNDPROC(HWND hWnd, uint message, WPARAM wParam, LPARAM lParam)
116.     {
117.         switch (message)
118.         {
119.             case PInvoke.WM_PAINT:
120.                 HDC hdc = PInvoke.BeginPaint(hWnd, out PAINTSTRUCT ps);
121.                 _ = PInvoke.GetClientRect(hWnd, out RECT rect);
122.                 _ = PInvoke.FillRect(hdc, rect, new DefaultSafeHandle(PInvoke.GetStockObject(GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH)));
123.                 _ = PInvoke.EndPaint(hWnd, ps);
124.                 return new LRESULT();
125.             case PInvoke.WM_CLOSE when m_bIsClosed:
126.                 goto default;
127.             case PInvoke.WM_CLOSE:
128.                 m_bIsClosed = true;
129.                 Closed?.Invoke(this, null);
130.                 goto default;
131.             case PInvoke.WM_SIZE:
132.                 ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
133.                 return new LRESULT();
134.             case PInvoke.WM_CREATE:
135.                 return new LRESULT();
136.             case PInvoke.WM_DESTROY:
137.                 PInvoke.PostQuitMessage(0);
138.                 return new LRESULT();
139.             default:
140.                 return PInvoke.DefWindowProc(hWnd, message, wParam, lParam);
141.         }
142.     }
144.     private void ResizeWindowToDesktopWindowXamlSourceWindowDimensions()
145.     {
146.         if (m_bIsClosed) return;
147.         _ = PInvoke.GetClientRect(m_hwnd, out RECT rect);
148.         _ = PInvoke.SetWindowPos(
149.             m_native.WindowHandle,
150.             new HWND(),
151.             0, 0,
152.             rect.Width, rect.Height,
153.             SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW);
154.     }
155. }
157. public partial class DesktopWindow
158. {
159.     private static readonly unsafe HINSTANCE g_hInstance = new((void*)Process.GetCurrentProcess().Handle);
161.     // win32 window class name for top-level WinUI desktop windows
162.     private const string s_windowClassName = "WinUIDesktopWin32WindowClass";
164.     // Default window title for top-level WinUI desktop windows
165.     private const string s_defaultWindowTitle = "WinUI Desktop";
167.     private static unsafe WNDCLASSEXW RegisterDesktopWindowClass(WNDPROC lpfnWndProc)
168.     {
169.         if (!PInvoke.GetClassInfoEx(new DefaultSafeHandle(g_hInstance), s_windowClassName, out WNDCLASSEXW wndClassEx))
170.         {
171.             wndClassEx.cbSize = (uint)Marshal.SizeOf(wndClassEx);
172.             wndClassEx.style = WNDCLASS_STYLES.CS_HREDRAW | WNDCLASS_STYLES.CS_VREDRAW;
173.             wndClassEx.cbClsExtra = 0;
174.             wndClassEx.cbWndExtra = 0;
175.             wndClassEx.hCursor = PInvoke.LoadCursor(new HINSTANCE(), PInvoke.IDC_ARROW);
176.             wndClassEx.hbrBackground = (HBRUSH)((nint)SYS_COLOR_INDEX.COLOR_WINDOW + 1);
177.             wndClassEx.hInstance = g_hInstance;
179.             fixed (char* lps_windowClassName = s_windowClassName)
180.             {
181.                 wndClassEx.lpszClassName = lps_windowClassName;
182.             }
184.             wndClassEx.lpfnWndProc = lpfnWndProc;
185.             _ = PInvoke.RegisterClassEx(wndClassEx);
187.             return wndClassEx;
188.         }
189.         return default;
190.     }
192.     private static unsafe HWND CreateDesktopWindow() =>
193.         PInvoke.CreateWindowEx(
194.             0,                                  // Extended Style
195.             s_windowClassName,                  // name of window class
196.             s_defaultWindowTitle,               // title-bar string
197.             WINDOW_STYLE.WS_OVERLAPPEDWINDOW | WINDOW_STYLE.WS_VISIBLE,  // top-level window
198.             int.MinValue,                       // default horizontal position
199.             (int)SHOW_WINDOW_CMD.SW_HIDE,       // If the y parameter is some other value,
200.                                                 // then the window manager calls ShowWindow with that value as the nCmdShow parameter
201.             int.MinValue,                       // default width
202.             int.MinValue,                       // default height
203.             new HWND(),                         // no owner window
204.             null,                               // use class menu
205.             new DefaultSafeHandle(g_hInstance),
206.             null);
208.     private partial class DefaultSafeHandle(nint invalidHandleValue, bool ownsHandle) : SafeHandle(invalidHandleValue, ownsHandle)
209.     {
210.         public DefaultSafeHandle(nint handle) : this(handle, true) => SetHandle(handle);
212.         public override bool IsInvalid => handle != nint.Zero;
214.         protected override bool ReleaseHandle() => true;
215.     }
216. }
218. public partial class DesktopWindow
219. {
220.     /// <summary>
221.     /// Create a new <see cref="DesktopWindow"/> instance.
222.     /// </summary>
223.     /// <param name="launched">Do something after <see cref="DesktopWindowXamlSource"/> created.</param>
224.     /// <returns>The new instance of <see cref="DesktopWindow"/>.</returns>
225.     public static Task<DesktopWindow> CreateAsync(Action<DesktopWindowXamlSource> launched)
226.     {
227.         TaskCompletionSource<DesktopWindow> taskCompletionSource = new();
229.         new Thread(() =>
230.         {
231.             try
232.             {
233.                 DesktopWindowXamlSource source;
234.                 using (HookWindowingModel hook = new())
235.                 {
236.                     source = new DesktopWindowXamlSource();
237.                 }
239.                 DesktopWindow window = new() { WindowXamlSource = source };
241.                 launched(source);
242.                 taskCompletionSource.SetResult(window);
244.                 MSG msg = new();
245.                 while (msg.message != PInvoke.WM_QUIT)
246.                 {
247.                     if (PInvoke.PeekMessage(out msg, new HWND(), 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
248.                     {
249.                         _ = PInvoke.DispatchMessage(msg);
250.                     }
251.                 }
252.             }
253.             catch (Exception e)
254.             {
255.                 taskCompletionSource.SetException(e);
256.             }
257.         })
258.         {
259.             Name = nameof(DesktopWindowXamlSource)
260.         }.Start();
262.         return taskCompletionSource.Task;
263.     }
264. }

复制代码

这样创建的窗口还存在一些问题，但是我不知道该怎么办理，所以该方法还是仅供参考。
末了附上示例应用：https://github.com/wherewhere/CoreAppUWP/tree/wuxc
MUXC 篇：【UWP】让 UWP 本身托管本身 —— Windows App SDK 篇

（由于微软迟迟不正式发布 .NET Core App 对 UWP 的支持，所以本文章实际仍处于未完成状态，源码也暂时未上传至 Github，作者会在微软正式发布之后完善文章并更新源码。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。