> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# من Win32 إلى WinUI: واجهات Windows عبر أربعين سنة
- URL: https://arabroot.io/articles/من-win32-الى-winui-واجهات-windows-عبر-اربعين-سنة/
- Published: 2026-11-20T11:43:30.000Z
- Updated: 2026-11-20T12:41:26.000Z
- Description: لماذا جاءت كل تقنية لبناء واجهات Windows من Win32 إلى WinForms وWPF وWinUI، وما الذي بقي منها، مع النافذة نفسها مبنية بأربع طرق ومقاسة بالأرقام على Windows 11.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, Windows للمسؤولين والمطورين

افتح الإعدادات Settings في Windows 11، ثم افتح بجانبها لوحة التحكم Control Panel القديمة من قائمة ابدأ، وقارن بين النافذتين. الأولى بخطوط كبيرة وزوايا مستديرة وأيقونات حديثة، والثانية بأزرار صغيرة ومربعات اختيار تشبه ما كنت تراه في Windows XP، وإذا تعمقت قليلاً فسوف تجد نوافذ خصائص Properties لم يتغير شكلها كثيراً منذ Windows 95\. وقد يبدو هذا إهمالاً من Microsoft، ولكنه في الحقيقة أوضح صورة لقصة واجهات Windows كلها: كل جيل من تقنيات بناء الواجهات جاء فوق الجيل الذي قبله ولم يحذفه، لأن ملايين البرامج التي تعمل في الشركات والبنوك والمصانع كتبت بالجيل القديم، وتوقف أي منها عن العمل بعد تحديث يعني أن يتوقف المستخدم عن الترقية. ولذلك تجد اليوم في جهاز واحد برامج مكتوبة بأربع أو خمس تقنيات مختلفة، تعمل بجانب بعضها في الشاشة نفسها، والمستخدم لا يعرف الفرق.

وفي مثل هذا اليوم، 20 نوفمبر، من سنة 1985 شحنت Microsoft النسخة الأولى من Windows كإضافة رسومية فوق MS-DOS، كما تذكر صفحة [تاريخ Microsoft لسنة 1985](https://learn.microsoft.com/en-us/shows/history/history-of-microsoft-1985?ref=arabroot.io). ومنذ ذلك اليوم مرت على المطورين أسماء كثيرة: Win32 وMFC وVisual Basic وWinForms وWPF وSilverlight وUWP وWinUI وMAUI، وكل اسم منها قدم في وقته على أنه الطريقة الجديدة لبناء تطبيقات Windows. وإذا كنت مطوراً يبدأ تطبيق سطح مكتب Desktop Application اليوم، أو مسؤولاً يرث تطبيقاً داخلياً كتب قبل عشرين سنة، فالسؤال الذي يهمك ليس حفظ هذه الأسماء، وإنما أن تفهم لماذا جاء كل منها، وما الذي بقي منه، وما الذي يجمعها كلها تحت السطح.

وهذا المقال من مرحلة Windows للمطورين، ويأتي بعد مقالي واجهة Win32 وأول نافذة Win32، وهو مقال تاريخ ومفاهيم أكثر منه دليلاً عملياً، ولكننا لن نكتفي بالحكاية، فقد بنينا النافذة نفسها بأربع طرق على جهاز Windows 11 حقيقي، وقسنا ثمن كل طبقة بالأرقام، وفحصنا النوافذ المفتوحة على سطح مكتب يعمل لنرى أي تقنية تقف خلف كل منها.

[![](https://arabroot.io/content/images/2026/11/win32-api-basics-cover-cover.webp)دليلواجهة Win32 API: كيف يكلم برنامجك نظام Windows؟نقرأ واجهة Win32 ببرامج C صغيرة على Windows 11: أين يعيش كود الدوال، ولماذا يتلف الاسم العربي مع نسخة A، وكيف تقرأ GetLastError وHRESULT دون أن يخدعك رقم قديم.](https://arabroot.io/articles/%D9%88%D8%A7%D8%AC%D9%87%D8%A9-win32-api-%D9%83%D9%8A%D9%81-%D9%8A%D9%83%D9%84%D9%85-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC%D9%83-%D9%86%D8%B8%D8%A7%D9%85-windows/)[![](https://arabroot.io/content/images/2026/11/win32-first-window-cover-cover.webp)دليلأول برنامج Win32 بلغة C: نافذة وحلقة الرسائلنكتب نافذة Win32 بلغة C ونسجل كل رسالة تصلها، ثم نجعلها عربية بـ WS\_EX\_LAYOUTRTL ونرى لماذا يعلن Windows بعد خمس ثوان أن البرنامج لا يستجيب.](https://arabroot.io/articles/%D8%A7%D9%88%D9%84-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC-win32-%D8%A8%D9%84%D8%BA%D8%A9-c-%D9%86%D8%A7%D9%81%D8%B0%D8%A9-%D9%88%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D8%B1%D8%B3%D8%A7%D8%A6%D9%84/)[![](https://arabroot.io/content/images/2026/11/win32-processes-files-cover-cover.webp)دليلWin32 للعمليات والملفات: CreateProcess وCreateFileنشغل برامج أخرى ونقرأ مخرجها ونفتح الملفات بلغة C على Windows 11 بصلاحيات مستخدم عادي، ونرى لماذا تتجمد الأدوات مع الأنابيب ولماذا يبقى الملف مفتوحاً بعد أن تغلقه.](https://arabroot.io/articles/win32-%D9%84%D9%84%D8%B9%D9%85%D9%84%D9%8A%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D9%85%D9%84%D9%81%D8%A7%D8%AA-createprocess-%D9%88createfile/)[![](https://arabroot.io/content/images/2026/11/com-to-winrt-cover-cover.webp)دليلمن COM وActiveX إلى WinRT: معمارية Windows للمطوريننتتبع ثلاثين سنة من OLE وDCOM وActiveX و.NET حتى Windows Runtime، ثم نفتح WinRT على Windows 11 من PowerShell ومن C++ ومن ملف winmd لنرى أنه COM بإضافات.](https://arabroot.io/articles/%D9%85%D9%86-com-%D9%88activex-%D8%A7%D9%84%D9%89-winrt-%D9%85%D8%B9%D9%85%D8%A7%D8%B1%D9%8A%D8%A9-windows-%D9%84%D9%84%D9%85%D8%B7%D9%88%D8%B1%D9%8A%D9%86/)

وسوف نناقش في هذا المقال ما يلي:

- البداية في 1985: النافذة والرسالة وإجراء النافذة، والفكرة التي ما زالت تحت كل شيء.
- Visual Basic وMFC: لماذا احتاج المطورون طبقة فوق Win32 من السنوات الأولى.
- Windows XP والعناصر ذات الأنماط Visual Styles: كيف تغير شكل الأزرار دون أن يتعطل برنامج قديم، ولماذا يكذب رقم الإصدار.
- الدقة العالية High DPI: مشكلة لم يتوقعها أحد في 1985.
- WinForms في 2002 وWPF في 2006: طريقتان مختلفتان تماماً للنافذة نفسها.
- Silverlight وWindows 8 وUWP: محاولة البداية من الصفر، ولماذا لم يتبعها أغلب المطورين.
- WinUI وWindows App SDK وMAUI: الاتجاه الحالي.
- مختبر يبني النافذة نفسها بأربع طرق، ويفحص ماذا يعمل على سطح مكتب حقيقي، وجدول قرار لتطبيق جديد اليوم.

## المختبر: نافذة واحدة بأربع طرق

قبل القصة نجهز ما سوف نرجع إليه في كل قسم: نافذة صغيرة بعنوان «تطبيق المبيعات» فيها سطر نص عربي ومربع كتابة وزر «حفظ»، كلها من اليمين إلى اليسار Right-to-Left، ونبنيها أربع مرات. الأولى بلغة C مباشرة على Win32 دون أي ملف وصف Manifest، والثانية بالكود نفسه حرفاً حرفاً ولكن مع Manifest، والثالثة بـ WinForms، والرابعة بـ WPF، والاثنتان الأخيرتان على .NET 10\. والنسختان الأوليان تبنيان بمترجم MinGW-w64 داخل Container مؤقت من Alpine، والأخريان بـ .NET SDK المثبت في الجهاز، دون أي حزمة NuGet إضافية:

```bash
cd win32
docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.sh
cd ..
powershell -NoProfile -ExecutionPolicy Bypass -File run.ps1
```

والسكربت `run.ps1` يشغل أربعة سكربتات بالترتيب: الأول يبني نسختي WinForms وWPF في مجلد مؤقت حتى لا تنزل ملفات `obj` و`bin` في مجلد المقال، والثاني يشغل كل نسخة ثلاث مرات ويقيس الزمن حتى تظهر نافذتها والذاكرة والوحدات Modules التي حملتها، ويعد النوافذ الأبناء داخلها، ويأخذ لقطة شاشة Screenshot لها ثم يغلقها برسالة `WM_CLOSE`، والثالث يقرأ كلاس Class كل نافذة مفتوحة على سطح المكتب والوحدات المحملة في عمليتها، والرابع يعد حزم Windows App SDK المثبتة. وكل ذلك بصلاحيات مستخدم عادي Standard User، ودون أي تغيير في السجل Registry، والسكربت الأخير يحذف المجلد المؤقت. وهذا مخرج البناء:

```text
dotnet SDK: 10.0.400   (cd C:\lab\src)
dotnet build winforms : exit 0 in 3.8 s;     0 Warning(s) |     0 Error(s)
dotnet build wpf : exit 0 in 4.5 s;     0 Warning(s) |     0 Error(s)

What each version ships (the program folder):
  Win32 classic   1 files,   20,992 bytes   (hello-classic.exe)
  Win32 themed    1 files,   22,016 bytes   (hello-themed.exe)
  WinForms        5 files,  183,028 bytes   (HelloWinForms.deps.json, HelloWinForms.dll, HelloWinForms.exe, HelloWinForms.pdb, HelloWinForms.runtimeconfig.json)
  WPF             5 files,  184,465 bytes   (HelloWpf.deps.json, HelloWpf.dll, HelloWpf.exe, HelloWpf.pdb, HelloWpf.runtimeconfig.json)
  plus, for WinForms and WPF, the shared runtime already on the machine: Microsoft.WindowsDesktop.App 10.0.11 [C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App]
  Microsoft.NETCore.App 10.0.11: 79,823,136 bytes in 189 files
  Microsoft.WindowsDesktop.App 10.0.11: 98,953,592 bytes in 287 files
```

ولاحظ من الآن الفرق في الحجم: نسخة Win32 ملف واحد بحجم 21 KB تقريباً، ونسختا .NET خمسة ملفات بحجم 180 KB تقريباً، ولكن ذلك لأن الثقيل مثبت مسبقاً في الجهاز: بيئة التشغيل .NET Runtime بحجم 80 MB، ومكتبات سطح المكتب WindowsDesktop بحجم 99 MB، ولو أردت نشر التطبيق على جهاز لا توجد فيه هذه البيئة فسوف تحملها معك. وسوف نعود إلى هذه الأرقام في كل قسم.

![أربع لقطات حقيقية للنافذة نفسها مبنية بـ Win32 دون Manifest ومع Manifest وWinForms وWPF](https://arabroot.io/content/images/2026/11/windows-ui-history-04-four-windows.webp)

النافذة نفسها بأربع طرق، لقطات من تشغيلها على Windows 11 بدقة عرض 150%.

## 1985: نافذة ورسالة وإجراء نافذة

الفكرة التي بني عليها Windows 1.0 بسيطة، وما زالت تعمل في جهازك الآن دون تغيير في جوهرها: كل شيء على الشاشة نافذة Window لها رقم يسمى مقبض النافذة HWND، وكل نافذة تنتمي إلى كلاس نافذة Window Class مسجل في النظام، وكل كلاس له دالة واحدة تسمى إجراء النافذة Window Procedure يستقبل الرسائل Messages. والرسالة هي الطريقة الوحيدة التي يخبر بها النظام البرنامج بما حدث: ضغط المستخدم زراً في لوحة المفاتيح، أو حرك الفأرة، أو غطت نافذة أخرى جزءاً من نافذتك فيجب أن ترسمه من جديد. والبرنامج من جهته يدور في حلقة رسائل Message Loop لا تنتهي: يأخذ الرسالة التالية من الطابور Queue، ويمررها إلى إجراء النافذة المناسب، ثم يعود ليأخذ التالية. وقد بنينا هذه الحلقة سطراً سطراً في مقال أول نافذة Win32 في هذه المرحلة، فلن نعيدها هنا، وتشرحها Microsoft في صفحة [About Messages and Message Queues](https://learn.microsoft.com/en-us/windows/win32/winmsg/about-messages-and-message-queues?ref=arabroot.io).

والمكتبتان اللتان تحملان هذا العالم هما USER وGDI، وأسماؤهما اليوم `user32.dll` و`gdi32.dll`: الأولى تدير النوافذ والرسائل ولوحة المفاتيح والفأرة، والثانية ترسم الخطوط والنصوص والصور بالبكسل. وفوقهما مجموعة كلاسات جاهزة يسجلها النظام نفسه، مثل `BUTTON` و`EDIT` و`STATIC` و`LISTBOX`، فإذا أردت زراً في نافذتك فأنت تنشئ نافذة صغيرة من كلاس `BUTTON` داخل نافذتك، أي أن الزر نفسه نافذة لها مقبض وإجراء وترسل لك رسالة عندما يضغط عليها المستخدم. وهذه النقطة سوف تفسر لنا لاحقاً الفرق الكبير بين WinForms وWPF.

وكانت البرمجة بهذه الطريقة في الثمانينيات تتطلب صبراً كبيراً، فبرنامج «Hello World» الذي يعرض نافذة فيها جملة واحدة يحتاج قرابة مئة سطر من C، وأصبح كتاب Charles Petzold «Programming Windows» الصادر عن Microsoft Press في 1988 هو الطريق الذي تعلم منه جيل كامل هذه الأسطر. ثم جاء الانتقال الكبير في 1993 مع Windows NT 3.1، ثم Windows 95، إلى واجهة Win32: الدوال نفسها تقريباً، ولكن بعناوين ذاكرة 32 بت بدل 16، وبعزل حقيقي بين البرامج في NT. وقد روينا قصة النواة التي جاءت معها في [قصة Windows NT وDave Cutler](https://arabroot.io/articles/%D9%82%D8%B5%D8%A9-windows-nt-%D9%88-dave-cutler/). والمهم هنا أن Win32 لم يغير الفكرة: النافذة والرسالة والإجراء بقيت كما هي، وهذا ما سمح بنقل البرامج من Windows 3.1 إلى Windows 95 بجهد معقول.

ونسخة Win32 في المختبر هي هذا الجيل بالضبط، وهذا ما وجده السكربت عندما عد النوافذ داخلها بالدالة `EnumChildWindows` وقرأ الوحدات التي حملتها:

```text
Win32 classic  class ArabRootHelloWin32
               child HWNDs: 3 = Static, Edit, Button
               comctl32.dll:
               UI modules: GDI32.dll, USER32.dll, uxtheme.dll
               screenshot 460x157
```

وفي المخرج أعلاه لاحظ التالي:

- **الكلاس `ArabRootHelloWin32`:** هو الاسم الذي سجلناه في الكود بالدالة `RegisterClassExW`، ونافذتنا الرئيسية من هذا الكلاس.
- **ثلاث نوافذ أبناء:** النص والمربع والزر ثلاث نوافذ حقيقية من الكلاسات `Static` و`Edit` و`Button`، أنشأناها بالدالة `CreateWindowExW` نفسها التي أنشأنا بها النافذة الرئيسية.
- **لا توجد `comctl32.dll` في القائمة:** هذه النسخة لم تطلب مكتبة العناصر المشتركة Common Controls أصلاً، فرسم `user32.dll` الزر والمربع بالشكل القديم، وهذا ما يقودنا إلى قصة Windows XP بعد قليل.

## Visual Basic وMFC: الطبقة الأولى فوق Win32

مئة سطر لنافذة واحدة رقم مقبول لمن يكتب نظام تشغيل، ولكنه غير مناسب إطلاقاً لموظف في قسم المحاسبة يريد شاشة إدخال بيانات، ولذلك ظهرت طبقتان فوق Win32 مبكراً جداً، كل منهما لجمهور مختلف.

الأولى Visual Basic في 1991، وكانت فكرتها جديدة تماماً في وقتها رغم بساطتها: ترسم النافذة بالفأرة، فتسحب زراً من صندوق الأدوات وتضعه حيث تريد، ثم تضغط عليه مرتين فيفتح لك مكان تكتب فيه ما يحدث عند الضغط. وكل تفاصيل الكلاسات والرسائل والحلقة مخفية عنك تماماً. وانتشر Visual Basic في الشركات انتشاراً هائلاً، حتى أن آخر إصداراته، Visual Basic 6 من 1998، ما زالت برامجه تعمل في مؤسسات كثيرة حتى اليوم، وتنص [سياسة دعم Visual Basic 6](https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-basic-6/visual-basic-6-support-policy?ref=arabroot.io) على أن ملفات تشغيله مدعومة في Windows 11، بينما بيئة التطوير نفسها IDE غير مدعومة منذ سنوات. أي أن Microsoft تتعهد بتشغيل برامج كتبت قبل أكثر من ربع قرن، ولا تتعهد بأن تستطيع كتابة برنامج جديد بالأداة نفسها، وهذا وحده يلخص فلسفة Windows في التوافق.

والطبقة الثانية MFC، واختصاراً Microsoft Foundation Classes، في 1992 مع مترجم C/C++ 7.0، وكانت لمطوري C++ الذين يريدون قوة Win32 كاملة دون كتابة كل سطر بأيديهم: كلاس `CWnd` يغلف النافذة، و`CButton` يغلف الزر، وجدول رسائل Message Map يربط كل رسالة بدالة في الكلاس. وMFC لم تخف Win32 كما فعل Visual Basic، وإنما نظمته، فالمطور ما زال يرى المقابض والرسائل، ولكن في كلاسات. وما زالت MFC جزءاً من Visual Studio حتى اليوم، كما تذكر صفحة [MFC Desktop Applications](https://learn.microsoft.com/en-us/cpp/mfc/mfc-desktop-applications?ref=arabroot.io)، وما زالت تقف خلف تطبيقات كبيرة، كما سوف نرى في مخرج المختبر عندما نصل إلى Outlook.

ومن المهم أن تلاحظ أن الطبقتين لم تغيرا ما يحدث تحتهما: الزر في برنامج Visual Basic أو MFC هو نافذة `BUTTON` نفسها، وحلقة الرسائل نفسها تدور في مكان ما داخل المكتبة. والذي تغير هو كمية الكود التي يكتبها المطور. وفي الفترة نفسها ظهر نموذج المكونات COM الذي سمح لبرنامج Visual Basic أن يستعمل عنصراً كتبه مطور C++، وهو موضوع مقالين في هذه المرحلة.

## Windows XP: أزرار جديدة دون أن يتعطل برنامج قديم

في 2001 أراد فريق Windows XP أن يغير شكل كل شيء: أزرار مستديرة الحواف، وألوان، وتأثير عند مرور الفأرة. والمشكلة أن ملايين البرامج كانت تفترض الشكل القديم، فبعضها يرسم فوق الزر، وبعضها يحسب أحجام العناصر بالبكسل على أساس الحدود القديمة، وتغيير الشكل للجميع فجأة يعني أن يظهر جزء منها مشوهاً. والحل الذي اختارته Microsoft أصبح نمطاً تكرر بعد ذلك عشرين سنة: لا تغير القديم، وأضف الجديد بجانبه، ودع البرنامج يطلبه صراحة.

فوضعت Microsoft نسختين من مكتبة العناصر المشتركة `comctl32.dll` في النظام: الإصدار 5 القديم في `System32`، والإصدار 6 الجديد في مخزن المكونات الجانبية WinSxS. والبرنامج الذي لا يقول شيئاً يحصل على الشكل القديم، والبرنامج الذي يريد الجديد يضع في ملفه وصفاً بلغة XML اسمه Manifest يقول فيه إنه يعتمد على الإصدار 6\. وتشرح صفحة [Common Control Versions](https://learn.microsoft.com/en-us/windows/win32/controls/common-control-versions?ref=arabroot.io) الإصدارات وما أضافه كل منها. وهذا هو الفرق الوحيد بين نسختي Win32 في المختبر، فالكود واحد، والنسخة الثانية فيها Manifest يطلب الإصدار 6، ويعلن أيضاً أن البرنامج يدعم الدقة العالية كما سوف نشرح في القسم التالي:

```xml
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <dependency>
    <dependentAssembly>
      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
    </dependentAssembly>
  </dependency>
  <application xmlns="urn:schemas-microsoft-com:asm.v3">
    <windowsSettings>
      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
    </windowsSettings>
  </application>
</assembly>
```

ويدخل هذا الملف في البرنامج كمورد Resource رقمه 1 ونوعه 24، وهذا ما يفعله السطر `1 24 "themed.manifest"` في ملف الموارد. وعندما شغلنا النسخة الثانية قرأ السكربت ما يلي:

```text
Win32 themed   class ArabRootHelloWin32
               child HWNDs: 3 = Static, Edit, Button
               comctl32.dll: 6.10 from WinSxS (its FileVersion text says '5.82 (WinBuild.160101.0800)')
               UI modules: comctl32.dll, GDI32.dll, USER32.dll, uxtheme.dll
               screenshot 690x237
```

وهنا قابلنا مشكلة أثناء كتابة المختبر تستحق أن تعرفها. فالنسخة الأولى من السكربت كانت تقرأ إصدار `comctl32.dll` من النص `FileVersion` في معلومات الملف، فطبعت `5.82` للنسخة التي فيها Manifest، فظننا أن الـ Manifest لم يعمل، مع أن الأزرار في اللقطة كانت بالشكل الجديد بوضوح. ثم قارنا الملف في WinSxS بالملف في System32، فتبين أن نص الإصدار في الاثنين هو `5.82 (WinBuild.160101.0800)`، بينما الأرقام الفعلية للإصدار، أي الحقلان `FileMajorPart` و`FileMinorPart`، هي 6.10 في WinSxS و5.82 في System32\. والدرس أن نص الإصدار في خصائص الملف قد يكون مضللاً في مكتبات النظام، فإذا أردت أن تعرف أي نسخة حملها برنامج فانظر إلى المسار الذي حملت منه، وإلى أرقام الإصدار لا إلى النص.

ولاحظ أيضاً كيف يعمل الاختيار: النسخة الأولى لم تحمل `comctl32.dll` أصلاً، والثانية حملت الإصدار 6 من WinSxS. وقد شرح Raymond Chen في مدونة The Old New Thing أن الاختيار بين الإصدارين لا يتم مرة واحدة للبرنامج كله، وإنما عند كل استدعاء لإنشاء نافذة، بحسب سياق التفعيل Activation Context النشط في تلك اللحظة، وكتب عن ذلك مقالاً بعنوان [How can you use both versions 5 and 6 of the common controls within the same module?](https://devblogs.microsoft.com/oldnewthing/20140508-00/?p=1043&ref=arabroot.io). وهذا بالضبط ما رأيناه في نسخة WinForms كما سوف يأتي، فقد حملت الإصدارين معاً في العملية نفسها.

## الدقة العالية High DPI: مشكلة لم يتوقعها أحد في 1985

برامج Win32 القديمة كتبت على افتراض أن الشاشة 96 نقطة في البوصة DPI، وأن الزر عرضه 75 بكسل ويبقى كذلك. ثم جاءت الشاشات عالية الدقة، فأصبح الزر نفسه على شاشة 4K صغيراً جداً لا يكاد يقرأ. والحل جاء على مراحل: أولاً تكبير كل شيء في النظام، ثم في Windows 8.1 في 2013 دعم دقة مختلفة لكل شاشة Per-Monitor DPI، ثم الإصدار الثاني من هذا الدعم Per-Monitor V2 في Windows 10 سنة 2017\. والنمط نفسه تكرر: البرنامج الذي لا يعلن شيئاً يعامل كبرنامج قديم لا يعرف الدقة DPI Unaware، فيرسم بالبكسل كأن الشاشة 96 نقطة، ثم يكبر Windows الصورة الناتجة كلها، فتبدو أكبر ولكن بحروف مشوشة قليلاً، أما البرنامج الذي يعلن دعمه فمسؤول عن رسم نفسه بالحجم الصحيح. وتشرح Microsoft ذلك في صفحة [High DPI Desktop Application Development on Windows](https://learn.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows?ref=arabroot.io).

والجهاز الذي شغلنا عليه المختبر شاشته 2560 في 1440 بتكبير 150%، أي 144 نقطة في البوصة. والكود في المختبر يكتب الأحجام على أساس 96 ثم يضربها في الدقة التي يعطيها النظام، والنسخة التي ليس فيها Manifest يعطيها النظام 96 دائماً، فرسمت نفسها بعرض 460 بكسل كما ظهر في المخرج، ثم كبرها Windows على الشاشة. أما النسخة التي أعلنت Per-Monitor V2 فأخذت 144، ورسمت بعرض 690 بكسل بخط أكبر وحروف حادة. وهذا ما تراه في اللقطتين العلويتين في الصورة أعلاه: الحجم مختلف، والكود واحد، والفرق سطر في Manifest. ولذلك إذا اشتكى مستخدم من برنامج داخلي يظهر مشوشاً على شاشة المحمول الجديدة فابدأ من هنا، قبل أن تفكر في إعادة كتابته.

## 2002: WinForms وعالم .NET

في فبراير 2002 أطلقت Microsoft إطار .NET Framework 1.0 ولغة C#، ومعهما مكتبة WinForms لبناء الواجهات. وكانت الفكرة أن يحصل مطور C# على تجربة Visual Basic نفسها، أي مصمماً مرئياً Visual Designer تسحب فيه العناصر وتكتب كود الأحداث، ولكن بلغة حديثة وبيئة تشغيل تدير الذاكرة. والمهم معمارياً أن WinForms لم ترسم شيئاً بنفسها، وإنما غلفت عناصر Win32 الموجودة: الكائن `Button` في C# ينشئ تحته نافذة Win32 من كلاس الأزرار، ويحول رسائلها إلى أحداث Events في .NET. وهذا ما رآه المختبر بوضوح:

```text
WinForms       class WindowsForms10.Window.8.app.0.2360855_r3_ad1
               child HWNDs: 3 = WindowsForms10.Static.app.0.2360855_r3_ad1, WindowsForms10.Edit.app.0.2360855_r3_ad1, WindowsForms10.Button.app.0.2360855_r3_ad1
               comctl32.dll: 5.82 from WinSxS (its FileVersion text says '5.82 (WinBuild.160101.0800)') / 6.10 from WinSxS (its FileVersion text says '5.82 (WinBuild.160101.0800)')
               UI modules: comctl32.dll, coreclr.dll, DWrite.dll, GDI32.dll, System.Windows.Forms.dll, USER32.dll, uxtheme.dll
               screenshot 462x155
```

وفي المخرج أعلاه لاحظ التالي:

- **ثلاث نوافذ أبناء كما في Win32:** النص والمربع والزر نوافذ حقيقية، ولكن بأسماء كلاسات جديدة مثل `WindowsForms10.Button…`. فـ WinForms تسجل كلاساً خاصاً بها يعتمد على كلاس الأزرار الأصلي من Win32، وهذه تقنية قديمة في Win32 اسمها Superclassing، ولذلك تبدو أزرار WinForms مثل أزرار Windows تماماً، لأنها هي.
- **الإصداران معاً من `comctl32.dll`:** 5.82 و6.10، وكلاهما محمل في العملية نفسها، وهذا ما شرحه Raymond Chen عن سياق التفعيل: السطر `ApplicationConfiguration.Initialize()` في أول البرنامج يفعل الأنماط الحديثة للنوافذ التي تنشأ بعده.
- **`coreclr.dll`:** بيئة تشغيل .NET نفسها، وهي التي تجعل البرنامج 66 وحدة بدل 27، وسوف نرى ثمن ذلك في الأرقام.

والاتجاه من اليمين إلى اليسار في WinForms خاصيتان: `RightToLeft` التي تقلب اتجاه النص داخل العناصر، و`RightToLeftLayout` التي تعكس ترتيب العناصر في النافذة كلها، وهي المقابل المباشر للراية `WS_EX_LAYOUTRTL` التي استعملناها في نسخة Win32، لأنها تفعل الشيء نفسه تحتها. وقصة WinForms لم تنته في 2002، ففي ديسمبر 2018 فتحت Microsoft مصدرها على [GitHub](https://github.com/dotnet/winforms?ref=arabroot.io)، وفي سبتمبر 2019 وصلت مع WPF إلى .NET الحديثة في [إعلان .NET Core 3.0](https://devblogs.microsoft.com/dotnet/announcing-net-core-3-0/?ref=arabroot.io)، وما زالت تتلقى تحسينات في كل إصدار من .NET حتى الإصدار 10 الذي استعملناه. أي أن تقنية عمرها 24 سنة ما زالت خياراً حياً، والسبب بسيط: لا يوجد طريق أسرع منها لبناء شاشة إدخال بيانات داخلية.

## 2006: WPF والرسم بدل النوافذ

في نوفمبر 2006 جاء إطار WPF، واختصاراً Windows Presentation Foundation، مع .NET Framework 3.0، وكان قطيعة حقيقية مع كل ما سبق. والسبب أن فريق WPF رأى أن نموذج «كل عنصر نافذة» وصل إلى حدوده: لا تستطيع أن تضع صورة وفيديو داخل زر، ولا أن تدور عنصراً بزاوية، ولا أن تكبر الواجهة كلها بوضوح على شاشة عالية الدقة، لأن كل عنصر نافذة مستقلة يرسمها GDI بالبكسل. فقرر الفريق أن تكون للبرنامج نافذة Win32 واحدة فقط، وأن ترسم WPF كل شيء داخلها بنفسها عبر DirectX، كما ترسم الألعاب مشاهدها. وجاء معها وصف الواجهة بلغة XAML، وهي XML تصف العناصر وتخطيطها، وربط البيانات Data Binding الذي يربط العنصر بخاصية في كود C# فيتحدث تلقائياً عندما تتغير. وتشرح صفحة [WPF Architecture](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/wpf-architecture?ref=arabroot.io) هذا التصميم، ومنه طبقة الرسم milcore التي تعمل فوق DirectX. وهذا ما وجده المختبر:

```text
WPF            class HwndWrapper[HelloWpf;;be1ac4ab-022a-4c67-845a-016465f2c118]
               child HWNDs: 0
               comctl32.dll:
               UI modules: coreclr.dll, d3d9.dll, dwrite.dll, GDI32.dll, PresentationCore.dll, PresentationFramework.dll, USER32.dll, uxtheme.dll, wpfgfx_cor3.dll
               screenshot 682x193
```

وفي المخرج أعلاه لاحظ التالي:

- **صفر نوافذ أبناء:** النص والمربع والزر في اللقطة تبدو مثل نسخة WinForms، ولكنها ليست نوافذ إطلاقاً، وإنما أشكال ترسمها WPF داخل نافذتها الوحيدة. ولذلك لا تستطيع أدوات Win32 القديمة التي تفحص النوافذ أن ترى عناصر WPF، وتحتاج إلى أدوات تفهم شجرة عناصر WPF نفسها.
- **النافذة الوحيدة كلاسها `HwndWrapper[...]`:** أي أن WPF ما زالت تحتاج نافذة Win32 واحدة لتستقبل الرسائل من النظام، لوحة المفاتيح والفأرة وتغير الحجم، وتحولها إلى أحداثها الخاصة.
- **`d3d9.dll` و`wpfgfx_cor3.dll` بدل `comctl32.dll`:** الرسم كله عبر Direct3D 9 وطبقة الرسم الخاصة بـ WPF، ولا تحتاج WPF مكتبة العناصر المشتركة أصلاً.

وهذا التصميم أعطى WPF قوة لم تكن ممكنة قبلها، فالمكونات تتداخل وتتحرك وتتكبر بلا حدود، ولكنه جاء بثمن ظهر في أرقام المختبر بوضوح:

```text
Start until the window exists (ms), working set and private bytes (MB) 1.5 s later, loaded modules, three rounds:
  Win32 classic  round 1:   228 ms   WS   13.3 MB   private    1.9 MB    25 modules
  Win32 classic  round 2:   119 ms   WS   13.3 MB   private      2 MB    25 modules
  Win32 classic  round 3:    71 ms   WS   13.3 MB   private    1.9 MB    25 modules
  Win32 themed   round 1:   153 ms   WS   13.9 MB   private      2 MB    27 modules
  Win32 themed   round 2:    84 ms   WS   13.9 MB   private      2 MB    27 modules
  Win32 themed   round 3:   168 ms   WS   13.9 MB   private      2 MB    27 modules
  WinForms       round 1:   502 ms   WS   50.7 MB   private     13 MB    66 modules
  WinForms       round 2:   515 ms   WS   51.1 MB   private     13 MB    66 modules
  WinForms       round 3:   544 ms   WS   48.5 MB   private   11.3 MB    66 modules
  WPF            round 1:  1278 ms   WS  111.9 MB   private   60.4 MB   102 modules
  WPF            round 2:   980 ms   WS  111.6 MB   private   60.4 MB   102 modules
  WPF            round 3:   897 ms   WS    111 MB   private   59.8 MB   102 modules
```

وفي المخرج أعلاه لاحظ التالي:

- **الذاكرة الخاصة Private Bytes:** وهي الذاكرة التي تخص العملية وحدها ولا تتشاركها مع غيرها، 2 MB في Win32، و13 MB في WinForms، و60 MB في WPF، لنافذة فيها ثلاثة عناصر فقط. والفرق بين Win32 وWinForms هو ثمن بيئة .NET، والفرق بين WinForms وWPF هو ثمن محرك الرسم والخطوط وشجرة العناصر.
- **مجموعة العمل Working Set:** 13 MB في Win32 لأنها تضم مكتبات النظام المشتركة مع كل البرامج، فلا تقرأها كتكلفة البرنامج وحده.
- **زمن ظهور النافذة:** أقل من ربع ثانية في Win32، ونصف ثانية في WinForms، وقرابة ثانية في WPF. ولاحظ أن التشغيل الأول بعد البناء مباشرة، في محاولة سابقة للسكربت، كان أبطأ بكثير من هذه الأرقام، فقد احتاجت WinForms 13 ثانية وWPF قرابة 6 ثوان في المرة الأولى، لأن ملفات بيئة التشغيل لم تكن في ذاكرة التخزين المؤقت بعد، ولأن الملفات الجديدة تفحص عند أول تشغيل. ولذلك لا تحكم على زمن بدء تطبيق من أول تشغيل له.

وهذه الأرقام لا تعني أن WPF بطيئة في التطبيقات الحقيقية، فهي تقيس الثمن الثابت لكل إطار مع نافذة فارغة تقريباً، وفي تطبيق فيه آلاف الصفوف ورسوم بيانية قد تكون WPF أسرع من غيرها لأنها ترسم بمعالج الرسوم GPU. ولكنها تفسر لماذا لا تكتب أداة صغيرة تعمل في الخلفية بـ WPF، ولماذا يبقى Win32 خيار برامج النظام والأدوات الصغيرة.

![مقارنة عدد النوافذ الأبناء في Win32 وWinForms وWPF كما عدها المختبر](https://arabroot.io/content/images/2026/11/windows-ui-history-02-hwnds.webp)

Win32 وWinForms: كل عنصر نافذة. WPF: نافذة واحدة وكل ما داخلها مرسوم.

![جدول بالأرقام يقارن حجم البرنامج وزمن ظهور النافذة والذاكرة والوحدات المحملة لأربع نسخ](https://arabroot.io/content/images/2026/11/windows-ui-history-05-numbers.webp)

ثمن كل طبقة بالأرقام من المختبر.

## Silverlight وWindows 8 وUWP: محاولة البداية من الصفر

بعد WPF بسنة واحدة، في 2007، أخذت Microsoft فكرة XAML إلى المتصفح باسم Silverlight، لتنافس Flash من Adobe في تطبيقات الويب الغنية وتشغيل الفيديو. وانتشر Silverlight سنوات في مواقع البث والأنظمة الداخلية، ثم جاءت الهواتف الذكية التي لم تدعم الإضافات Plugins في متصفحاتها، ثم HTML5 الذي جعل الإضافات غير ضرورية، فتوقف تطويره، وانتهى دعم آخر إصداراته في أكتوبر 2021 بحسب [صفحة دورة حياة Silverlight 5](https://learn.microsoft.com/en-us/lifecycle/products/silverlight-5?ref=arabroot.io). والدرس الذي تعلمه كثير من المطورين في الشركات هنا كان قاسياً: تطبيقات داخلية كاملة بنيت على تقنية اختفت، واضطرت الشركات إلى إعادة كتابتها.

ثم جاء Windows 8 في أكتوبر 2012 بأكبر محاولة لإعادة البداية في تاريخ واجهات Windows: نوع جديد من التطبيقات يعمل بملء الشاشة، ويثبت من متجر Microsoft فقط، ويعمل في صندوق رمل Sandbox لا يصل إلى ملفات المستخدم إلا بإذن، ويكتب بـ XAML فوق واجهة جديدة اسمها Windows Runtime واختصاراً WinRT. وكانت الفكرة منطقية من جهة الأمان، فتطبيقات Win32 تستطيع أن تفعل أي شيء يستطيعه المستخدم، وتطبيقات المتجر لا تستطيع إلا ما يسمح لها به. ولكن المطورين وجدوا أنفسهم أمام خيار صعب: إعادة كتابة تطبيقاتهم لتعمل في Windows 8 فقط، وفي صندوق رمل يمنعها مما اعتادت عليه، وسوق متجر صغير لم يكبر بعد. فبقي أغلبهم على Win32 وWinForms وWPF. ثم جاء Windows 10 في 2015 بنسخة معدلة من الفكرة نفسها باسم المنصة الموحدة UWP، واختصاراً Universal Windows Platform، وتطبيق واحد يعمل على الحاسب والجهاز اللوحي وXbox والهاتف، كما تشرح [صفحة UWP](https://learn.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide?ref=arabroot.io). ثم توقف هاتف Windows، وبقيت UWP منصة تطبيقات Windows نفسها أكثر من منصة المطورين.

وWinRT نفسها مبنية على نموذج COM القديم، مع إضافات تجعلها قابلة للاستدعاء من C# وJavaScript وC++ بطريقة طبيعية، وهذه القصة هي موضوع مقال من COM إلى WinRT في هذه المرحلة. والمهم هنا أن تطبيقات UWP ما زالت معنا، وقد وجدها المختبر على سطح المكتب: الإعدادات `SystemSettings` ولوحة الكتابة `TextInputHost`، ونافذتهما من الكلاس `Windows.UI.Core.CoreWindow`، والعملية `ApplicationFrameHost` التي ترسم الإطار حول تطبيقات UWP.

## WinUI وWindows App SDK: فصل الواجهة عن إصدار Windows

بعد تجربة UWP فهمت Microsoft مشكلة أساسية: العناصر الحديثة كانت جزءاً من Windows نفسه، فإذا أضافت عنصراً جديداً في تحديث لـ Windows 10 لم يستطع المطور استعماله حتى يحدث كل مستخدميه نظامهم، وهذا قد يأخذ سنوات في الشركات. فجاء الحل على مرحلتين. الأولى WinUI 2 في 2018: نسخ العناصر الحديثة في حزمة NuGet يحملها التطبيق معه، كما تشرح [صفحة WinUI 2](https://learn.microsoft.com/en-us/windows/apps/winui/winui2/?ref=arabroot.io)، وما زالت تطبيقات كبيرة تعتمد عليها، منها Windows Terminal الذي وجده المختبر يحمل `Microsoft.UI.Xaml.dll` من الحزمة `Microsoft.UI.Xaml.2.8`. والمرحلة الثانية WinUI 3، وأخرجت طبقة XAML كلها من Windows إلى حزمة مستقلة، وجعلتها متاحة لتطبيقات سطح المكتب العادية لا لتطبيقات UWP فقط، وصدرت مع Windows App SDK 1.0 في 16 نوفمبر 2021 بحسب [ملاحظات الإصدارات](https://learn.microsoft.com/en-us/windows/apps/windows-app-sdk/stable-channel?ref=arabroot.io). وتقدم Microsoft اليوم WinUI 3 على أنها الواجهة الحديثة المقترحة لتطبيقات Windows الجديدة في [صفحة WinUI 3](https://learn.microsoft.com/en-us/windows/apps/winui/winui3/?ref=arabroot.io).

وفصل الواجهة عن النظام له نتيجة تراها في أي جهاز يستعمل تطبيقات حديثة، فكل تطبيق يحتاج إصداراً معيناً من بيئة Windows App SDK، وهذه البيئة تثبت كحزم مستقلة. وقد عد السكربت الرابع ما في الجهاز الذي شغلنا عليه المختبر:

```text
Windows App SDK runtime packages: 33
Microsoft.WindowsAppRuntime.1.4     2 package(s): 4000.1309.2056.0 X64, 4000.1309.2056.0 X86
Microsoft.WindowsAppRuntime.1.5     2 package(s): 5001.373.1736.0 X64, 5001.373.1736.0 X86
Microsoft.WindowsAppRuntime.1.6     2 package(s): 6000.519.329.0 X64, 6000.519.329.0 X86
Microsoft.WindowsAppRuntime.1.7     8 package(s): 7000.522.1444.0 X64, 7000.617.2103.0 X64, ... 7000.785.2325.0 X86
Microsoft.WindowsAppRuntime.1.8     9 package(s): 8000.770.947.0 X64, 8000.806.2252.0 X64, ... 8000.994.2142.0 X86
Microsoft.WindowsAppRuntime.2      10 package(s): 2.2.0.0 X64, 2.3.0.0 X64, ... 2.7.0.0 X86

WinUI 2 packages (Microsoft.UI.Xaml):
Microsoft.UI.Xaml.2.7               2 package(s)
Microsoft.UI.Xaml.2.8               3 package(s)
Microsoft.UI.Xaml.CBS               1 package(s)
```

ثلاث وثلاثون حزمة من بيئة Windows App SDK في جهاز واحد، من الإصدار 1.4 إلى الإصدار 2، ولكل إصدار أكثر من نسخة، لأن كل تطبيق قد يطلب نسخة مختلفة، والنظام يحتفظ بها جنباً إلى جنب حتى لا يتعطل أحدها بتحديث الآخر. وهذا هو الحل نفسه الذي رأيناه مع `comctl32.dll` في Windows XP، أي نسخ متعددة جنباً إلى جنب Side-by-Side، بعد عشرين سنة وبتقنية تغليف أحدث. وإذا كنت مسؤولاً عن أجهزة الشركة فهذه الحزم ليست مخلفات يجب حذفها، وإنما متطلبات تطبيقات مثبتة.

وفي 2022 جاء .NET MAUI، الذي يكتب فيه المطور تطبيقاً واحداً بـ C# وXAML يعمل على Windows وAndroid وiOS وmacOS، ويعمل على Windows فوق WinUI 3 نفسها، كما تشرح صفحة [What is .NET MAUI](https://learn.microsoft.com/en-us/dotnet/maui/what-is-maui?ref=arabroot.io). وبجانب كل ذلك خيار لم تصنعه Microsoft أصلاً ولكنه أصبح من أكثر الخيارات انتشاراً: أن تكتب الواجهة بتقنيات الويب، وتضعها في متصفح مدمج، كما يفعل Electron الذي بني عليه VS Code، أو WebView2 من Microsoft الذي يعتمد على محرك Edge.

![خط زمني لتقنيات واجهات Windows من 1985 إلى 2021 في ثلاثة مسارات](https://arabroot.io/content/images/2026/11/windows-ui-history-01-timeline.webp)

تقنيات واجهات Windows في ثلاثة مسارات: Win32 نفسه، والأطر التي تغلفه، والأطر التي ترسم كل شيء بنفسها.

## ماذا يعمل على سطح مكتب حقيقي اليوم؟

بعد كل هذه الأجيال، ما الذي يعمل فعلاً على جهاز مطور عادي؟ السكربت الثالث في المختبر أخذ كل نافذة رئيسية ظاهرة على سطح المكتب لحظة تشغيله، وقرأ كلاسها بالدالة `GetClassName`، وقرأ قائمة الوحدات المحملة في عمليتها، وبحث فيها عن علامة كل تقنية: `System.Windows.Forms.dll` لـ WinForms، و`PresentationFramework.dll` لـ WPF، ومكتبات `mfc` لـ MFC، و`Microsoft.UI.Xaml.dll` لـ WinUI، و`Windows.UI.Xaml.dll` لـ XAML الخاصة بالنظام. ولم يطبع السكربت عناوين النوافذ، لأنها قد تحمل أسماء ملفات أو رسائل خاصة. وهذا ما وجده:

```text
Process              Class                         UI
-------              -----                         --
ApplicationFrameHost ApplicationFrameWindow        UWP / system XAML
chrome               Chrome_WidgetWin_1            Chromium
Code                 Chrome_WidgetWin_1            Chromium (window class)
explorer             CabinetWClass                 Microsoft.UI.Xaml from SystemApps + UWP / system XAML
explorer             Progman                       Microsoft.UI.Xaml from SystemApps + UWP / system XAML
notepad++            Notepad++                     Win32 only (none of the above)
OUTLOOK              rctrl_renwnd32                WinForms + MFC
SystemSettings       Windows.UI.Core.CoreWindow    Microsoft.UI.Xaml from SystemApps + UWP / system XAML
TextInputHost        Windows.UI.Core.CoreWindow    Microsoft.UI.Xaml from SystemApps + UWP / system XAML
WindowsTerminal      CASCADIA_HOSTING_WINDOW_CLASS Microsoft.UI.Xaml from Microsoft.UI.Xaml.2.8 + UWP / system XAML

10 visible top-level windows with a title
```

وفي المخرج أعلاه لاحظ التالي:

- **Notepad++ ما زال Win32 خالصاً:** برنامج مفتوح المصدر بدأ في 2003 ويعمل بالطريقة التي شرحناها في قسم 1985، ولهذا هو سريع وخفيف.
- **Outlook يجمع MFC وWinForms في عملية واحدة:** تطبيق عمره عقود، بنيت أجزاؤه في أجيال مختلفة، وما زالت كلها تعمل معاً. وهذا هو الوضع الطبيعي في التطبيقات الكبيرة، لا الاستثناء.
- **مستكشف الملفات File Explorer يحمل XAML الحديثة:** النافذة نفسها من الكلاس `CabinetWClass` الذي يعود إلى عقود، والعملية نفسها حملت مكتبة `Microsoft.UI.Xaml.dll` الحديثة. أي أن Microsoft نفسها لم تعد كتابة المستكشف من الصفر، وإنما أدخلت عناصر XAML في نافذة Win32 قديمة، والتقنية التي تسمح بذلك لأي تطبيق تسميها Microsoft جزر XAML واختصاراً XAML Islands، وتشرحها في [صفحة XAML Islands](https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/xaml-islands/xaml-islands?ref=arabroot.io).
- **Chrome وVS Code من الكلاس نفسه:** `Chrome_WidgetWin_1`، لأن VS Code مبني على Electron الذي يحمل محرك Chromium نفسه، ويرسم واجهته كلها كصفحة ويب.
- **كل سطر له كلاس نافذة Win32:** حتى أحدث تطبيقات XAML والمتصفح، لكل منها في النهاية نافذة مسجلة بكلاس، تستقبل الرسائل من النظام، وهذا ما سمح للسكربت أن يقرأها بدالة من Windows 1.0 تقريباً، ودون أي صلاحيات خاصة.

![جدول البرامج المفتوحة على سطح مكتب حقيقي وكلاس نافذة كل منها والتقنية التي وجدها المختبر](https://arabroot.io/content/images/2026/11/windows-ui-history-06-desktop-now.webp)

عشر نوافذ على سطح مكتب واحد، وست تقنيات مختلفة خلفها.

## ما الذي بقي من كل جيل؟

إذا وضعت كل هذه الأطر بجانب بعضها، كما في الصورة التالية، فسوف تجد أنها تختلف في كل شيء تقريباً: اللغة، وطريقة وصف الواجهة، ومحرك الرسم، وحجم بيئة التشغيل. ولكنها تلتقي كلها في الأسفل عند الطبقة نفسها التي بدأت في 1985: نافذة user32 لها حلقة رسائل. وهذا ليس تفصيلاً تاريخياً، وإنما له نتائج عملية تقابلها كل يوم:

- **التجمد بالطريقة نفسها:** أي تطبيق، من Win32 إلى WinUI 3، يتجمد إذا توقف الخيط الذي يدير حلقة رسائله عن أخذ الرسائل لأكثر من خمس ثوان، فيكتب Windows في عنوانه «لا يستجيب Not Responding». والسبب الأشهر واحد في كل الأطر: عمل طويل، مثل استعلام قاعدة بيانات أو قراءة ملف كبير، يتم في الخيط نفسه الذي يرسم الواجهة.
- **إمكانية الوصول Accessibility:** قارئ الشاشة ولوحة المفاتيح وAlt+Tab تعمل مع كل هذه الأطر لأنها تعرف النافذة والرسالة، والأطر التي ترسم بنفسها مثل WPF وWinUI تقدم لقارئ الشاشة شجرة عناصرها الخاصة عبر واجهة UI Automation.
- **الاتجاه من اليمين إلى اليسار:** كل إطار له اسم مختلف للإعداد نفسه، `WS_EX_LAYOUTRTL` في Win32، و`RightToLeftLayout` في WinForms، و`FlowDirection` في WPF وWinUI، والفكرة واحدة: اعكس ترتيب العناصر كلها، لا النص فقط.
- **التوافق قبل كل شيء:** كل جيل جديد أضيف بجانب القديم، والقديم ما زال يعمل، ولذلك تستطيع أن تبدأ تطبيقاً جديداً بـ WinUI 3 وتستدعي فيه دالة Win32 مباشرة عندما تحتاجها، وتستطيع أن تضع عنصر WPF داخل تطبيق WinForms قديم كما تشرح صفحة [WPF and Win32 Interoperation](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/wpf-and-win32-interoperation?ref=arabroot.io).

![أربعة أعمدة تبين طبقات Win32 وWinForms وWPF وWinUI 3 وكلها تنتهي عند نافذة user32 ونواة win32k](https://arabroot.io/content/images/2026/11/windows-ui-history-03-layers.webp)

كل إطار ينتهي عند الطبقة نفسها: نافذة user32 لها حلقة رسائل.

## مشكلة قابلتنا أثناء كتابة المختبر: لقطة معكوسة

السكربت يأخذ لقطة كل نافذة بالدالة `PrintWindow`، التي تطلب من النافذة أن ترسم نفسها في صورة في الذاكرة، وهي طريقة تعمل حتى لو كانت النافذة خلف نوافذ أخرى. وعندما فتحنا اللقطات الأولى وجدنا النوافذ الأربع معكوسة كما في المرآة: الحروف العربية مقلوبة، والزر على اليمين بدل اليسار، وأزرار الإغلاق والتصغير في الجهة الخطأ. والنوافذ على الشاشة نفسها كانت سليمة تماماً. والسبب أن النوافذ الأربع تستعمل التخطيط المعكوس من اليمين إلى اليسار، و`PrintWindow` يرسم النافذة المعكوسة في سياق رسم Device Context معكوس أيضاً، فتخرج الصورة معكوسة. والحل كان أن نقلب الصورة أفقياً مرة واحدة بعد الالتقاط، فتعود كما تظهر على الشاشة. والدرس لمن يكتب أدوات تلتقط نوافذ أو تطبعها: التخطيط المعكوس RTL Mirroring يؤثر في كل ما يرسم بسياق النافذة، لا في الشاشة فقط، وإذا ظهرت لك صورة معكوسة من نافذة عربية فابحث عن هذا قبل أن تشك في الكود.

## تطبيق سطح مكتب جديد اليوم: من أين تبدأ؟

لا توجد إجابة واحدة، ومن يقول لك إن تقنية واحدة هي الصحيحة دائماً لم يعمل مع تطبيقات حقيقية في شركات حقيقية. ولكن تاريخ أربعين سنة يعطيك قاعدة واضحة: اختر بحسب عمر التطبيق المتوقع وفريقك ونوع الواجهة، لا بحسب آخر إعلان. وتقدم Microsoft مقارنتها الخاصة في صفحة [Get started with Windows app development](https://learn.microsoft.com/en-us/windows/apps/get-started/?ref=arabroot.io)، والجدول التالي يلخص ما رأيناه في هذا المقال بالأرقام:

![جدول قرار يقارن Win32 وWinForms وWPF وWinUI 3 و.NET MAUI وWebView2 بحسب الحالة ونقاط القوة والضعف](https://arabroot.io/content/images/2026/11/windows-ui-history-07-choose.webp)

جدول قرار لتطبيق سطح مكتب جديد على Windows.

وبعض الملاحظات على الجدول:

- **تطبيق قائم يعمل لا يعاد كتابته لأن تقنيته قديمة:** برنامج WinForms عمره 15 سنة يخدم قسم المحاسبة كل يوم لا يحتاج إعادة كتابة بـ WinUI 3، وإنما يحتاج نقلاً إلى .NET الحديثة، وManifest يعلن دعم الدقة العالية، وربما عنصراً حديثاً هنا أو هناك. وإعادة الكتابة الكاملة هي أغلى قرار تقني تستطيع أن تتخذه، ومثال Silverlight يذكرك أن التقنية الجديدة نفسها قد لا تعيش أطول من القديمة.
- **التقنية الأحدث ليست الأنضج:** WinUI 3 هي اتجاه Microsoft الحالي، ولكن أدواتها ومصمماتها ومكتباتها من الأطراف الثالثة أقل نضجاً من WPF وWinForms، ولذلك وازن بين المظهر الحديث وبين ما يحتاجه فريقك اليوم.
- **Win32 المباشر ليس للتطبيقات الكبيرة:** الأرقام تغري، 21 KB و2 MB، ولكن كل ما تحصل عليه مجاناً في الأطر الأخرى، من التخطيط إلى ربط البيانات إلى الدقة العالية، تكتبه بيدك هنا. فاحتفظ به للأدوات الصغيرة وبرامج النظام والمكونات التي يجب أن تعمل دون أي بيئة تشغيل.

## أخطاء شائعة Common Mistakes

- **الحكم على إصدار مكتبة من نص FileVersion:** في المختبر قال النص 5.82 عن مكتبة إصدارها الفعلي 6.10\. انظر إلى المسار الذي حملت منه، وإلى أرقام الإصدار.
- **نسيان Manifest في برنامج Win32 جديد:** النتيجة أزرار بشكل Windows 2000، ونافذة مشوشة على كل شاشة عالية الدقة، والكود نفسه صحيح. أضف Manifest يطلب الإصدار 6 من العناصر المشتركة ويعلن Per-Monitor V2.
- **عكس اتجاه النص بدل عكس التخطيط:** في WinForms تحتاج `RightToLeftLayout` مع `RightToLeft`، وإلا بقي الزر في مكانه وانقلب النص داخله فقط.
- **عمل طويل في خيط الواجهة:** يجمد أي تطبيق من أي جيل، لأن كلها تقوم على حلقة الرسائل نفسها. انقل العمل الطويل إلى خيط آخر أو استعمل `async`.
- **قياس زمن البدء من أول تشغيل:** كان أبطأ بعشرات المرات من التشغيل الثاني في المختبر. شغل عدة مرات وخذ المتوسط.
- **حذف حزم Windows App Runtime القديمة لتوفير المساحة:** كل نسخة قد تكون متطلباً لتطبيق مثبت، والنظام يحتفظ بها عمداً جنباً إلى جنب.
- **إعادة كتابة تطبيق يعمل لأن تقنيته «قديمة»:** التقنية القديمة في Windows لا تتوقف عادة، وVisual Basic 6 من 1998 ما زالت ملفات تشغيله مدعومة في Windows 11.

## تدريب عملي Practice

1. شغل السكربت `03-whats-running.ps1` على جهازك، وقارن ما تجده بالجدول أعلاه. كم تقنية مختلفة تعمل على سطح مكتبك الآن؟
2. احذف السطر `<dpiAwareness>` من ملف `themed.manifest` وأعد البناء، ثم شغل النسخة على شاشة بتكبير أكبر من 100%، وقارن حدة الحروف بالنسخة الأصلية.
3. في نسخة WinForms احذف السطر `RightToLeftLayout = true` وأعد البناء، ولاحظ ما الذي ينعكس وما الذي يبقى في مكانه.

## الخلاصة Summary

- كل تقنية واجهات في Windows منذ 1985 جاءت فوق التي قبلها ولم تحذفها، ولذلك يعمل في جهاز واحد Win32 وMFC وWinForms وXAML النظام وWinUI وChromium جنباً إلى جنب، كما رأينا في عشر نوافذ على سطح مكتب واحد.
- Win32 وWinForms يجعلان كل عنصر نافذة حقيقية، وWPF وWinUI ترسمان كل شيء داخل نافذة واحدة، وهذا يفسر الفرق في الشكل والقدرة والثمن: 2 MB و13 MB و60 MB من الذاكرة الخاصة للنافذة نفسها في المختبر.
- Microsoft تحل مشكلة التوافق بالطريقة نفسها منذ Windows XP: النسخة الجديدة بجانب القديمة، والبرنامج يطلبها صراحة، من `comctl32.dll` الإصدار 6 إلى 33 حزمة من Windows App SDK في جهاز واحد.
- كل الأطر تلتقي عند نافذة user32 وحلقة رسائلها، ولذلك تتجمد بالطريقة نفسها، وتعمل مع لوحة المفاتيح وقارئ الشاشة بالطريقة نفسها.
- اختر التقنية بحسب عمر التطبيق وفريقك ونوع الواجهة، ولا تعد كتابة تطبيق يعمل لأن تقنيته قديمة.

وفي المقال التالي من هذه المرحلة ننتقل من الواجهات إلى ما تحتها: المكتبات المشتركة DLL، وكيف يجد Windows المكتبة التي يطلبها برنامجك، ولماذا احتاج أصلاً إلى فكرة النسخ الجانبية التي رأيناها مع `comctl32.dll`.

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بشاشة 2560 في 1440 وتكبير 150% وصلاحيات مستخدم عادي: نسختا Win32 مبنيتان بـ MinGW-w64 GCC 14.2.0 في Container من alpine:3.22، ونسختا WinForms وWPF بـ .NET SDK 10.0.400 على .NET 10.0.11.