Тёмный режим и темы контрастности в приложениях Windows ── тёмная панель заголовка DWM, следование системной теме в WinForms/WPF, отрисовка при высокой контрастности

«Заменили служебные ПК на Windows 11, и сотрудники в тёмном режиме жалуются, что только у нашего бизнес-приложения панель заголовка ослепительно белая». «Сотрудник со слабовидением включил тему контрастности — и индикатор статуса на экране заказа пропал». Оба симптома за последние год-два стали чаще приходить как обращения.

Первый идёт от настройки «Цвета» в Windows 11, второй — от настроек специальных возможностей, но разработчику это выглядит одной проблемой: приложение не следует теме. И в самом деле фундамент решения общий. Не задавать цвета жёстко; прочитать системную настройку, заметить изменение и перерисовать. Эти три пункта.

В предыдущей статье «Доступность приложений Windows: UI Automation и разумное приспособление» разбирались механизм, через который программы чтения с экрана читают приложение (UI Automation), и основы имён, клавиатуры и цвета. Следование темам контрастности там затронуто, сам цветовой режим светлый/тёмный — нет. Эта статья — её парная: две оси — цветовой режим (светлый/тёмный) и темы контрастности — связывает на уровне реализации, в таком порядке: отрисовка панели заголовка диспетчером окон рабочего стола (DWM), следование системной теме в WinForms/WPF, отрисовка при теме контрастности. Читатели — разработчики, которые пишут и сопровождают бизнес-приложения на WinForms, WPF или Win32. Предпосылки — Windows 11 (тёмная панель заголовка — сборка 22000 и новее) и WinForms/WPF на .NET 9/10 (на .NET Framework 4.8 и .NET 8 часть реализуют вручную). Сложность — средняя.

flowchart TB
    accTitle: Ход этой статьи
    accDescr: Структура статьи, которая по порядку связывает две оси тем, почему по умолчанию светло, тёмную панель заголовка DWM, механизм обнаружения и следования, реализацию в WinForms и WPF, отрисовку при теме контрастности, выбор политики и проверку
    axes["Разобрать две оси тем"] --> why["Почему по умолчанию светло"]
    why --> dwm["Тёмная панель заголовка DWM"]
    dwm --> detect["Обнаружение и следование"]
    detect --> impl["Реализация WinForms/WPF"]
    impl --> hc["Отрисовка при теме контрастности"]
    hc --> policy["Политика и проверка"]

Рис. 1: Статья идёт одной нитью от разбора тем через механизмы, реализацию, темы контрастности и проверку.

1. Сначала вывод

• У «темы» Windows две оси. Светлый/тёмный (цветовой режим) в «Параметры > Персонализация > Цвета» и «Параметры > Специальные возможности > Темы контрастности». Вторая — палитра, ограниченная коэффициентом контрастности примерно 7:1 и выше, и это не то же самое, что светлый/тёмный. Пока тема контрастности включена, тёмный режим недоступен. Порядок проверки: «тема контрастности, затем светлый/тёмный».¹²
• Белая панель заголовка у существующего приложения — умолчание ради совместимости. Windows не знает, поддерживает ли приложение тёмный режим, поэтому по умолчанию считает все окна светлыми.³
• Панель заголовка делает тёмной DWMWA_USE_IMMERSIVE_DARK_MODE (значение 20) через DwmSetWindowAttribute. Передайте BOOL TRUE — рамка рисуется тёмной, когда система тёмная. Документированная поддержка — Windows 11 сборка 22000 и новее.⁴³
• Текущий режим читают UISettings.GetColorValue, изменения принимают через ColorValuesChanged. Официальная процедура Microsoft: если передний план (цвет текста по умолчанию) яркий — режим тёмный. Событие не гарантирует приход на поток UI, поэтому перед перерисовкой возвращайтесь на UI.³⁵
• В WinForms в .NET 9 появился Application.SetColorMode, в .NET 10 он перестал быть экспериментальным. Вызывайте SystemColorMode.System до Application.Run. Три ограничения: только Windows 11, выключен при теме контрастности, не следует за сменой настройки во время работы.⁶⁷²
• В WPF в .NET 9 появились тема Fluent и ThemeMode. ThemeMode="System" следует системе и также управляет затемнением окна. Однако операции из кода в .NET 10 всё ещё экспериментальны (WPF0001), стили Fluent — «в работе». Если остаётесь на прежней теме, подменяйте светлый и тёмный ResourceDictionary через DynamicResource.⁸⁹¹⁰
• При теме контрастности отображайте цвета на правильные пары системных цветов, убирайте изображения за текстом и рисуйте многоцветную графику двумя цветами переднего плана и фона. Определяйте через SPI_GETHIGHCONTRAST (SystemInformation.HighContrast в WinForms, SystemParameters.HighContrast в WPF); уведомления — WM_SYSCOLORCHANGE / WM_THEMECHANGED (в .NET — SystemEvents.UserPreferenceChanged).¹¹¹²¹³
• Поддержка тёмного режима не заменяет поддержку доступности. Тёмной палитре тоже нужен коэффициент контрастности 4,5:1, и передача информации не одним цветом нужна при любой теме.¹⁴¹⁵

Одной фразой: поддержка темы — это собрать цвета в одном месте, прочитать системную настройку, заметить изменение и перерисовать; но при теме контрастности полностью отдать пары системных цветов.

На схеме сплошная линия обозначает отношение, которое выполняется всегда, а пунктирная — условное отношение (условия указаны в пояснении к каждому отношению на странице сведений). Полный список отношений (всего 28, с доказательствами и степенью уверенности) и определения основных понятий собраны на странице сведений карты знаний (на японском). Данные: JSON-LD / Turtle

2. У «темы» две оси ── светлый/тёмный и темы контрастности

2.1. Светлый/тёмный (цветовой режим)

Цветовой режим в «Параметры > Персонализация > Цвета» Windows задаёт яркость переднего плана и фона для ОС и приложений в целом. Документация Microsoft определяет светлый как «тёмный передний план на светлом фоне», тёмный как «светлый передний план на тёмном фоне» и уточняет, что передний план здесь — «цвет текста по умолчанию». В тёмном режиме передний план (текст) светлый, фон тёмный.³

Эта настройка хранится в реестре HKCU\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize как значения DWORD AppsUseLightTheme (режим приложений) и SystemUsesLightTheme (режим самой Windows); они есть в справочнике настроек Microsoft.¹⁶ Но, как ниже, канонический путь чтения из приложения — UISettings WinRT.

2.2. Темы контрастности (высокая контрастность)

Тема контрастности, которую выбирают в «Параметры > Специальные возможности > Темы контрастности», использует палитру, ограниченную коэффициентом контрастности примерно 7:1 и выше, для пользователей, которым нужно сильное визуальное отделение переднего плана от фона. В Windows 11 встроены четыре темы: Aquatic, Desert, Dusk и Night sky; пользователь не только выбирает из них, но и по отдельности правит цвета фона, текста, гиперссылок, отключённого текста, выделенного текста и кнопок. Быстрое переключение — Left Alt+Left Shift+PrintScreen; если ничего не выбрано, применяется Aquatic.¹

Документация Microsoft прямо пишет: «не путайте темы контрастности со светлой и тёмной темами». Светлый/тёмный использует широкую палитру и не оптимизирован под максимальный контраст.¹ И важно: пока тема контрастности включена, тёмный режим недоступен. Application.SetColorMode в WinForms в это время тёмный режим не даёт, а RequestedTheme в XAML система перезаписывает.²¹⁷

2.3. Порядок проверки

Поэтому реализация приложения идёт в таком порядке. Сначала определить, включена ли тема контрастности; если да — полностью отдать системным цветам. Если нет — выбрать светлую или тёмную палитру.

flowchart TB
    accTitle: Две оси тем и порядок проверки
    accDescr: Если тема контрастности включена, полностью отдать пары системных цветов; если нет — прочитать цветовой режим светлый/тёмный и выбрать палитру приложения
    q1{"Тема контрастности включена?"}
    q1 -->|да| sys["Отдать пары системных цветов"]
    q1 -->|нет| q2{"Цветовой режим?"}
    q2 -->|светлый| light["Светлая палитра"]
    q2 -->|тёмный| dark["Тёмная палитра"]
    sys -.-> note["Тёмный режим недоступен"]

Рис. 2: Сначала проверяют тему контрастности; светлую или тёмную палитру выбирают, только если она выключена.

3. Почему существующие приложения в тёмном режиме остаются белыми

Окно состоит из двух областей. Неклиентская область — панель заголовка, рамка, кнопки заголовка — и клиентская область, которую рисует приложение. С Windows Vista неклиентскую область синтезирует и рисует DWM (диспетчер окон рабочего стола); приложение задаёт атрибуты отрисовки через DwmSetWindowAttribute.¹⁸

Документация Microsoft прямо объясняет, почему существующие приложения остаются белыми. «Windows не знает, может ли приложение поддерживать тёмный режим, и из соображений обратной совместимости предполагает, что не может». Есть платформы вроде WinUI и Windows App SDK, которые обрабатывают тёмный режим нативно, но приложения Win32 его часто не поддерживают, поэтому Windows по умолчанию даёт светлую панель заголовка.³

flowchart TB
    accTitle: Две области окна и кто их рисует
    accDescr: Неклиентскую область из панели заголовка и рамки рисует DWM, клиентскую — приложение или UI-платформа, поэтому тёмная поддержка нужна обеим
    win["Окно верхнего уровня"] --> nc["Неклиентская область (панель заголовка, рамка)"]
    win --> client["Клиентская область (содержимое экрана)"]
    nc --> dwm["DWM синтезирует и рисует"]
    client --> app["Рисует приложение или платформа"]
    dwm -.-> attr["Указание через DwmSetWindowAttribute"]
    app -.-> palette["Собственная палитра приложения"]

Рис. 3: Панель заголовка рисует DWM, содержимое — приложение, поэтому тёмная поддержка требует и указания DWM, и палитры приложения.

Отсюда два следствия. Первое: чтобы сделать панель заголовка тёмной, приложение должно явно попросить DWM. Второе: тёмной после этой просьбы становится только панель заголовка; клиентскую область нужно перекрасить самим. Документация тоже пишет, что «для полной поддержки тёмного режима вся поверхность приложения должна следовать тёмной теме», и оговаривает, что официальное руководство покрывает обнаружение и панель заголовка, а перекраску клиентской области не разбирает.³ Приложение с чёрной панелью заголовка и белым содержимым выглядит неестественнее, чем целиком белое.

flowchart TB
    accTitle: Почему по умолчанию светло
    accDescr: Windows не знает, поддерживает ли приложение тёмный режим, поэтому ради совместимости по умолчанию светлое; рамку по тёмной системной настройке рисует, только когда приложение передало TRUE в атрибут DWM
    unknown["Windows не знает, есть ли поддержка"] --> def["Ради совместимости умолчание — светлое"]
    def --> q{"Приложение передало TRUE?"}
    q -->|нет| light["Всегда светлая рамка"]
    q -->|да| follow["Рисовать по системной настройке"]

Рис. 4: Не зная о поддержке, Windows по умолчанию остаётся светлой и следует, только когда приложение явно указало.

4. Тёмная панель заголовка DWM ── DwmSetWindowAttribute

4.1. DWMWA_USE_IMMERSIVE_DARK_MODE

Атрибут, который делает панель заголовка тёмной, — DWMWA_USE_IMMERSIVE_DARK_MODE. Описание перечисления DWMWINDOWATTRIBUTE такое. «Разрешить рисовать рамку этого окна цветами тёмного режима, когда системная настройка тёмного режима включена. Из соображений совместимости все окна по умолчанию светлые независимо от системной настройки. pvAttribute указывает на BOOL: TRUE — уважать тёмный режим, FALSE — всегда светлый. Поддержка с Windows 11 сборки 22000».⁴

То есть TRUE — не «сделай тёмным», а разрешение «если система тёмная, можно рисовать тёмным». Если клиентскую область приложение уже готово красить тёмным, достаточно передать TRUE — панель заголовка последует системной настройке. Наоборот, если приложение всегда показывают светлым (ниже — «фиксированный светлый режим»), умолчание FALSE нормально.

Официальный C++-пример такого вида. В него входит и определение значения 20 самостоятельно для старых SDK, где константы в заголовке нет.³

#include <dwmapi.h>
#pragma comment(lib, "dwmapi.lib")

#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE
#define DWMWA_USE_IMMERSIVE_DARK_MODE 20
#endif

// Windows 11 (сборка 22000) или новее. Предполагается манифест
// с supportedOS для Windows 10 и новее (без него версия округляется до Windows 8)
bool IsWindows11OrGreater()
{
    OSVERSIONINFOEXW osvi{ sizeof(osvi) };
    osvi.dwMajorVersion = 10;
    osvi.dwMinorVersion = 0;
    osvi.dwBuildNumber = 22000;
    DWORDLONG mask = 0;
    VER_SET_CONDITION(mask, VER_MAJORVERSION, VER_GREATER_EQUAL);
    VER_SET_CONDITION(mask, VER_MINORVERSION, VER_GREATER_EQUAL);
    VER_SET_CONDITION(mask, VER_BUILDNUMBER, VER_GREATER_EQUAL);
    return ::VerifyVersionInfoW(
        &osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_BUILDNUMBER, mask) != FALSE;
}

// honorDarkMode = true: если система тёмная, панель заголовка тоже можно рисовать тёмной
void ApplyTitleBarTheme(HWND hwnd, bool honorDarkMode)
{
    if (!IsWindows11OrGreater())
    {
        // Документированная поддержка — сборка 22000 и новее. Ниже не вызываем, оставляем умолчание (светлое)
        LogInfo(L"DWMWA_USE_IMMERSIVE_DARK_MODE is not documented for this OS build; keeping the default light frame");
        return;
    }
    BOOL value = honorDarkMode ? TRUE : FALSE;
    HRESULT hr = ::DwmSetWindowAttribute(
        hwnd, DWMWA_USE_IMMERSIVE_DARK_MODE, &value, sizeof(value));
    if (FAILED(hr))
    {
        // Сбой на поддерживаемой ОС — аномалия. Не глотать молча: записать HRESULT и всплыть
        LogWarning(L"DwmSetWindowAttribute(DWMWA_USE_IMMERSIVE_DARK_MODE) failed: 0x%08X", hr);
    }
}

Почему ветвление по версии ОС — одной фразой. Документированная поддержка — Windows 11 сборка 22000 и новее.⁴ Сообщения, что то же значение срабатывает и на Windows 10, не редкость, но отображение бизнес-приложения нельзя сажать на недокументированное поведение. Если спроектировать «вызвать и при сбое сдаться», на Windows 10 вызов может успешно пройти — и панель заголовка станет тёмной на недокументированном поведении. На сборках ниже 22000 не вызывать и следовать документированному умолчанию «светлая панель заголовка»; сбой на поддерживаемой ОС записывать HRESULT в журнал и всплывать — только это. В интернете ходят и старый приём со значением 19, и вызов порядкового экспорта uxtheme.dll, чтобы затемнить общие элементы управления, — и то и другое закрытые API, никто не гарантирует поведение после обновления.

4.2. Когда вызывать ── пока HWND жив и каждый раз, когда его пересоздают

DwmSetWindowAttribute вызывают для HWND, поэтому после создания дескриптора окна. А формы WinForms при смене ShowInTaskbar и подобном пересоздают дескриптор. На новом HWND после пересоздания атрибута нет, поэтому место вызова — не «конструктор», а «место, которое вызывается каждый раз, когда создаётся дескриптор». В WinForms это OnHandleCreated, в WPF — SourceInitialized.

flowchart TB
    accTitle: Когда вызывать DwmSetWindowAttribute
    accDescr: Атрибут DWM задают после создания дескриптора окна, при пересоздании задают снова на новый дескриптор и задают снова при уведомлении о смене темы
    create["Создание HWND"] --> apply["Задать атрибут DWM"]
    apply --> run["Пока показано"]
    run -->|пересоздание дескриптора| create
    run -->|уведомление о смене темы| apply

Рис. 5: Атрибут DWM привязан к HWND, поэтому его задают заново при каждом создании и пересоздании.

P/Invoke в WinForms такой (безопасную запись DllImport см. в «Безопасный вызов Win32 API из C# — практическое руководство по P/Invoke (DllImport / LibraryImport / CsWin32)»).

using System.Runtime.InteropServices;

public partial class MainForm : Form
{
    private const int DWMWA_USE_IMMERSIVE_DARK_MODE = 20;

    [DllImport("dwmapi.dll")]
    private static extern int DwmSetWindowAttribute(
        IntPtr hwnd, int attribute, ref int value, int size);

    protected override void OnHandleCreated(EventArgs e)
    {
        base.OnHandleCreated(e);
        ApplyTitleBarTheme();
    }

    private void ApplyTitleBarTheme()
    {
        // Документированная поддержка — сборка 22000 и новее. Ниже не вызываем, оставляем умолчание (светлое).
        // Проверка, которая работает и на .NET Framework. На .NET Framework без манифеста
        // с supportedOS для Windows 10 и новее версия округляется до Windows 8
        // (на .NET 5 и новее можно OperatingSystem.IsWindowsVersionAtLeast(10, 0, 22000))
        if (Environment.OSVersion.Version < new Version(10, 0, 22000))
        {
            _logger.LogInformation("Dark title bar is not documented for this OS build; keeping the default light frame");
            return;
        }
        // 1 (TRUE) = если система тёмная, можно рисовать тёмным. 0 (FALSE) = всегда светлое
        int honorDarkMode = 1;
        int hr = DwmSetWindowAttribute(
            Handle, DWMWA_USE_IMMERSIVE_DARK_MODE, ref honorDarkMode, sizeof(int));
        if (hr < 0)
        {
            _logger.LogWarning("DwmSetWindowAttribute failed: 0x{Hr:X8}", hr);
        }
    }
}

Этот код нужен в приложениях на .NET 8 и старше, .NET Framework и Win32/MFC. Если в WinForms на .NET 9 и новее использовать Application.SetColorMode, а в WPF на .NET 9 и новее — ThemeMode, затемнение окна берёт на себя платформа (документация ThemeMode прямо пишет, что он «также управляет применением материала фона и тёмного режима к окну»).¹⁰ Двойной вызов вреда не несёт, но ответственность размывается — выберите одно.

В WPF HWND фиксируется к моменту SourceInitialized. Дескриптор берут из WindowInteropHelper.¹⁹

using System.Windows.Interop;

public partial class MainWindow : Window
{
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        var hwnd = new WindowInteropHelper(this).Handle;
        TitleBarTheme.Apply(hwnd, honorDarkMode: true); // тело — P/Invoke выше
    }
}

4.3. Цвет панели заголовка, цвет текста, цвет рамки и материал фона

В Windows 11 кроме выбора тёмный/светлый появились атрибуты, задающие сам цвет панели заголовка.

Три атрибута цвета возвращаются к системному умолчанию, если передать DWMWA_COLOR_DEFAULT (0xFFFFFFFF). Про цвет рамки оговорено: «менять цвет при смене состояния вроде активации окна — ответственность приложения».⁴ Материал фона задают перечислением DWM_SYSTEMBACKDROP_TYPE: DWMSBT_MAINWINDOW на Windows 11 соответствует Mica, DWMSBT_TRANSIENTWINDOW — Acrylic, но прямо написано, что «эффект материала может измениться в будущих Windows».²⁰

В бизнес-приложении место применения стоит продумывать осторожно. Если покрасить панель заголовка в цвет бренда, ответственность за контраст текста заголовка и кнопок на этом цвете ложится на вас. К двум состояниям тёмный/светлый добавляется ещё пара активное/неактивное. Для большинства бизнес-приложений правильный ответ — «следовать системному умолчанию (только TRUE для значения 20)»; цвет бренда — вариант, когда он действительно нужен.

flowchart TB
    accTitle: Как выбрать цвет панели заголовка
    accDescr: Если следовать системному умолчанию, достаточно TRUE для значения 20; покраска цветом бренда переносит на приложение гарантию контраста текста и кнопок заголовка и управление цветами активного/неактивного; возврат — передача DWMWA_COLOR_DEFAULT
    q{"Цвет панели заголовка?"}
    q -->|следовать системному умолчанию| dark["Только TRUE для значения 20"]
    q -->|покрасить цветом бренда| brand["Задать цветовые атрибуты (34-36)"]
    brand --> resp["Самим гарантировать контраст текста и кнопок"]
    brand --> states["Самим вести активное/неактивное"]
    brand -.-> reset["Возврат — COLOR_DEFAULT"]

Рис. 6: Выбор цвета бренда переносит на приложение ответственность за контраст и состояния; для большинства бизнес-приложений правильно следовать умолчанию.

5. Обнаружение системной темы и следование ── прочитать, заметить, перерисовать

Работа по следованию клиентской области раскладывается на три части. Прочитать текущую настройку, заметить изменение и перерисовать.

flowchart TB
    accTitle: Три шага обнаружения и следования
    accDescr: При запуске прочитать текущий цветовой режим через UISettings, заметить изменение уведомлениями вроде ColorValuesChanged, вернуться на поток UI и переприменить палитру приложения
    read["Прочитать: UISettings.GetColorValue"] --> paint["Перерисовать: снова применить палитру"]
    notice["Заметить: ColorValuesChanged"] --> ui["Вернуться на поток UI"]
    ui --> read
    paint -.-> dwm["Задать атрибут DWM снова"]

Рис. 7: Цикл «прочитать при запуске, заметить по уведомлению, вернуться на поток UI и перерисовать» — скелет следования теме.

5.1. Прочитать ── UISettings и «если передний план яркий — тёмный»

Официальная процедура Microsoft использует WinRT Windows.UI.ViewManagement.UISettings. Берут цвет переднего плана (цвет текста по умолчанию) через GetColorValue(UIColorType::Foreground), оценивают его воспринимаемую яркость целочисленной формулой — «яркий ли» — и считают тёмным режимом, если передний план яркий. Документация оговаривает, что формула — не строгая модель анализа яркости, а приближение, достаточное для классификации светлого и тёмного.³²¹

UISettings — класс WinRT, но из C# WPF/WinForms его вызывают напрямую, если поставить TargetFramework с версией Windows SDK вроде net8.0-windows10.0.19041.0 (устройство см. в «WinRT — это COM ── IInspectable, .winmd, языковые проекции и почему WinUI до сих пор стоит на двоичном контракте»). Можно читать реестр AppsUseLightTheme напрямую, но реестр — место хранения настройки, а не контракт API: канон чтения — UISettings, реестр оставьте диагностике.

flowchart TB
    accTitle: Пути чтения цветового режима
    accDescr: Канонический путь — взять цвет переднего плана через UISettings WinRT и классифицировать светлое/тёмное; AppsUseLightTheme в реестре — место хранения, его оставляют диагностике
    q["Сейчас светлый или тёмный"] --> uis["UISettings.GetColorValue"]
    q -.-> reg["Реестр AppsUseLightTheme"]
    uis --> fg["Оценить воспринимаемую яркость переднего плана"]
    fg --> ans["Если яркий — тёмный"]
    reg -.-> diag["Место хранения. Оставить диагностике"]

Рис. 8: Канонический путь чтения — UISettings; реестр лишь место хранения.

5.2. Заметить ── ColorValuesChanged не приходит на поток UI

Для обнаружения изменений тоже берут UISettings. Событие ColorValuesChanged возникает, когда изменилось значение цвета; официальное руководство тоже отслеживает смену настройки этим событием.⁵³ Практическая оговорка одна. Это событие не гарантирует приход на поток UI. Возвращайтесь на поток UI через Dispatcher WPF, Control.Invoke WinForms или общий SynchronizationContext и только потом трогайте элементы. Как жить с потоком UI — в «WPF и WinForms: async/await и поток UI».

Событие возникает и при смене акцентного цвета. Если перерисовывать только при смене светлый/тёмный, при каждом событии перепроверяйте и уведомляйте, только когда стало иначе, чем в прошлый раз. И по приоритету главы 2: если включена тема контрастности, яркость переднего плана смотреть нельзя. В теме контрастности с тёмным фоном вроде Aquatic передний план яркий, и по одной яркости получится ложное «тёмный». Тему контрастности проверяют раньше как отдельное состояние.

Следующий класс собирает этот порядок проверки в одном месте. SynchronizationContext для возврата на поток UI и проверку темы контрастности (SystemInformation.HighContrast в WinForms, SystemParameters.HighContrast в WPF, глава 8) передаёт вызывающая сторона. Следите за моментом создания. В WinForms в Program.Main ещё нет ни цикла сообщений, ни Control, SynchronizationContext.Current — null. Передавайте SynchronizationContext.Current после создания элемента, в конструкторе формы или OnLoad. В WPF можно передать new DispatcherSynchronizationContext(Application.Current.Dispatcher).

using Windows.UI.ViewManagement; // TargetFramework: net8.0-windows10.0.19041.0 и новее

public enum ThemeState { Light, Dark, HighContrast }

public sealed class SystemThemeWatcher : IDisposable
{
    private readonly UISettings _settings = new();
    private readonly SynchronizationContext _ui;
    private readonly Func<bool> _isHighContrast;

    private bool _disposed;

    public ThemeState Current { get; private set; }
    public event EventHandler? Changed;

    // ui: SynchronizationContext потока UI. Передать SynchronizationContext.Current
    //     после создания элемента или DispatcherSynchronizationContext в WPF
    // isHighContrast: () => SystemInformation.HighContrast (WinForms)
    //                 () => SystemParameters.HighContrast (WPF)
    public SystemThemeWatcher(SynchronizationContext ui, Func<bool> isHighContrast)
    {
        _ui = ui ?? throw new ArgumentNullException(nameof(ui));
        _isHighContrast = isHighContrast ?? throw new ArgumentNullException(nameof(isHighContrast));
        Current = Read();
        _settings.ColorValuesChanged += OnColorValuesChanged;
    }

    private ThemeState Read()
    {
        // Порядок как в главе 2: сначала тема контрастности. Тема контрастности
        // с тёмным фоном даёт яркий передний план, и по одной яркости выйдет ложное «тёмный»
        if (_isHighContrast()) return ThemeState.HighContrast;
        // Та же проверка, что в официальном руководстве: если передний план (цвет текста по умолчанию) яркий — тёмный
        var fg = _settings.GetColorValue(UIColorType.Foreground);
        bool isDark = (5 * fg.G + 2 * fg.R + fg.B) > 8 * 128;
        return isDark ? ThemeState.Dark : ThemeState.Light;
    }

    // Вызывать с потока UI. Можно и из уведомлений другим путём, вроде UserPreferenceChanged
    public void Refresh()
    {
        if (_disposed) return;
        var next = Read();
        // Между светлым и тёмным не уведомлять при том же состоянии, чтобы игнорировать смену только акцента.
        // Исключение при теме контрастности: даже если пользователь правит цвета темы, состояние остаётся HighContrast,
        // поэтому уведомлять и при том же состоянии, чтобы заново взять системные цвета
        if (next == Current && next != ThemeState.HighContrast) return;
        Current = next;
        Changed?.Invoke(this, EventArgs.Empty);
    }

    private void OnColorValuesChanged(UISettings sender, object args)
    {
        // Приход на поток UI не гарантирован, поэтому сначала вернуться на UI, потом проверка и уведомление.
        // Вызовы, уже стоявшие в очереди после Dispose, игнорирует флаг в Refresh
        _ui.Post(_ => Refresh(), null);
    }

    public void Dispose()
    {
        // Отписка только останавливает будущую доставку; вызовы, уже отправленные на поток UI, остаются.
        // Ставим флаг, и оставшиеся вызовы сами себя игнорируют (вызывать на потоке UI)
        _disposed = true;
        _settings.ColorValuesChanged -= OnColorValuesChanged;
    }
}

На уровне Win32 при смене настройки всем окнам верхнего уровня уходит WM_SETTINGCHANGE,²² а в .NET это доходит как SystemEvents.UserPreferenceChanged.²³ При переключении визуального стиля (включая включение темы контрастности) приходит WM_THEMECHANGED,²⁴ при смене системных цветов — WM_SYSCOLORCHANGE.²⁵ Писать разную обработку под каждый вид уведомления хрупче, чем при любом уведомлении вызывать одну и ту же обработку «прочитать и перерисовать»; это та же форма, что следование теме контрастности в предыдущей статье. Для SystemThemeWatcher выше это значит вызывать Refresh() и из обработчиков UserPreferenceChanged или StaticPropertyChanged.

flowchart TB
    accTitle: Пути уведомления о смене темы и потоки
    accDescr: ColorValuesChanged UISettings может прийти не на поток UI, поэтому возвращаются на UI; WM_SETTINGCHANGE доходит как SystemEvents.UserPreferenceChanged; WM_THEMECHANGED и WM_SYSCOLORCHANGE доходят в оконную процедуру. Все сходятся в одну повторную применение
    cvc["ColorValuesChanged"] --> marshal["Вернуться на поток UI"]
    upc["UserPreferenceChanged"] --> reapply["Прочитать и перерисовать"]
    wm["WM_THEMECHANGED и др."] --> reapply
    marshal --> reapply

Рис. 9: Путей уведомления несколько, все сходятся в одну обработку «прочитать и перерисовать».

5.3. Перерисовать ── собрать цвета в одном месте

Предпосылка перерисовки — цвета собраны в одном месте. Если Color.White и #FFFFFF размазаны по формам и XAML, места перерисовки не перечислить. В WinForms делают класс «палитра» (два экземпляра — светлый и тёмный), элементы берут цвета оттуда при запуске и при уведомлении. В WPF цвета собирают в ResourceDictionary, из XAML ссылаются через DynamicResource. В WinUI эта структура с самого начала есть как ThemeDictionaries.

flowchart TB
    accTitle: Структура, где цвета собраны в одном месте
    accDescr: В приложении по одной светлой и тёмной палитре; экраны берут цвета из палитры, выбранной по текущему режиму, поэтому объекты перерисовки можно перечислить
    mode["Текущий режим"] --> sel{"Какую брать?"}
    sel -->|светлый| pl["Светлая палитра"]
    sel -->|тёмный| pd["Тёмная палитра"]
    pl --> screens["Экраны и элементы"]
    pd --> screens
    hard["Размазанный Color.White"] -.-> cannot["Места перерисовки не перечислить"]

Рис. 10: Если палитра в одном месте, перерисовку можно перечислить; размазанный жёсткий код — нет.

Эта работа «собрать цвета» сразу работает и для поддержки тем контрастности, и для проверки коэффициента контрастности ниже. Главная стоимость поддержки тёмного режима — не вызовы API, а эта уборка.

6. Реализация в WinForms

6.1. .NET 9/10 ── Application.SetColorMode

В WinForms предварительная поддержка тёмного режима появилась в .NET 9 и «полностью интегрирована» в .NET 10. В Application.SetColorMode передают одно из трёх значений.⁶⁷

• SystemColorMode.Classic — умолчание. Светлое как раньше.
• SystemColorMode.System — следовать светлой/тёмной настройке Windows.
• SystemColorMode.Dark — тёмный.

Место вызова — до Application.Run, до создания элементов UI. В .NET 9 это была экспериментальная функция: без подавления WFO5001 в файле проекта была ошибка компиляции; с .NET 10 этой ошибки нет.²⁶

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.SetColorMode(SystemColorMode.System); // вызвать до создания UI
        Application.Run(new MainForm());
    }
}

При смене цветового режима System.Drawing.SystemColors переключается на соответствующие цвета, и стандартные элементы рисуются по ним.⁶ По устройству экспериментальное свойство SystemColors.UseAlternativeColorSet (SYSLIB5002) «заставляет системные KnownColor возвращать альтернативный набор цветов (сейчас — версия тёмного режима)»: сами системные цвета Win32 от настройки светлый/тёмный не меняются, поэтому альтернативный набор держит сторона .NET. Тот же документ пишет, что когда включена тема контрастности, всегда возвращаются текущие цвета Windows.²⁷

Зафиксируйте три ограничения из документации SetColorMode.²

1. Тёмный цветовой режим доступен только на Windows 11 и новее.
2. Когда включена тема контрастности, тёмный режим недоступен.
3. Даже с SystemColorMode.System приложение не следует автоматически, если настройка Windows изменилась во время работы.

Третий пункт в бизнес-приложениях часто становится обращением. Напишите в пользовательском объяснении, что решает настройка Windows на запуске и вступает в силу при следующем запуске. Если во что бы то ни стало следовать переключению во время работы, придётся пересоздавать форму — почти всегда это не окупается.

flowchart TB
    accTitle: Поток SetColorMode и ограничения
    accDescr: SetColorMode вызывают до Application.Run, SystemColors переключается на альтернативный набор, стандартные элементы следуют. Три ограничения: только Windows 11, выключен при теме контрастности, не следует за сменой настройки во время работы
    sc["SetColorMode (System)"] --> before["До Application.Run"]
    before --> colors["SystemColors на альтернативный набор"]
    colors --> ctrls["Стандартные элементы следуют"]
    sc -.-> c1["Только Windows 11"]
    sc -.-> c2["Выключен при теме контрастности"]
    sc -.-> c3["Не следует за сменой во время работы"]

Рис. 11: SetColorMode действует один раз до запуска и несёт три документированных ограничения.

6.2. Элементы с собственной отрисовкой и ApplyThemingImplicitly

Стандартные элементы следуют цветовому режиму приложения, но документация .NET 10 называет два исключительных случая. Если внутри элемента, который вы сами компонуете и рисуете, используются общие элементы управления Win32 вроде полос прокрутки, они остаются светлыми, пока явно не сделать opt-in. Наоборот, если наследуете существующий элемент, который следует теме, и хотите полностью сами контролировать отрисовку — делаете opt-out.⁷

В обоих случаях переопределяют Control.CreateParams и вызывают SetStyle(ControlStyles.ApplyThemingImplicitly, true/false) до чтения base.CreateParams. Ловушка этого API: конструктор базового класса читает CreateParams, поэтому в собственном конструкторе уже поздно.⁷

public partial class GanttChartControl : Control
{
    protected override CreateParams CreateParams
    {
        get
        {
            // Задать до чтения base.CreateParams. В конструкторе поздно
            SetStyle(ControlStyles.ApplyThemingImplicitly, true);
            return base.CreateParams;
        }
    }
}

flowchart TB
    accTitle: Когда успеть задать ApplyThemingImplicitly
    accDescr: ApplyThemingImplicitly фиксируется в момент, когда конструктор базы читает CreateParams, поэтому SetStyle нужно вызвать в переопределении CreateParams до base.CreateParams; в конструкторе производного класса уже поздно
    basector["Конструктор базы"] --> cp["Читает CreateParams"]
    cp --> st["К этому моменту нужен SetStyle"]
    st --> derived["Конструктор производного класса"]
    derived -.-> late["Вызов здесь уже поздний"]

Рис. 12: ApplyThemingImplicitly должен быть задан до того, как конструктор базы прочитает CreateParams.

Сама собственная отрисовка (OnPaint через GDI+) следует альтернативному набору, если использовать SystemColors / SystemBrushes / SystemPens. Места, где красят Color.White, и здесь заменяют на палитру выше.

6.3. .NET Framework 4.8 и .NET 8 и старше ── явно фиксировать светлый режим

Там, где нет SetColorMode, стандартной поддержки тёмного режима нет. Вариантов два.

1. Явно фиксировать светлый режим. Атрибут DWM оставить умолчанием FALSE (всегда светлая панель заголовка), клиентская область как раньше. Поддержку тем контрастности (глава 8) сделать обязательно.
2. Полностью поддержать самим. Собрать палитру, читать и следовать через UISettings, поставить TRUE в атрибут DWM и перекрасить всё, включая вид общих элементов управления.

У 2 приложение не полностью контролирует отрисовку общих элементов Win32 (полосы прокрутки, заголовки, кнопки раскрытия дерева и т. п.), поэтому часто получается состояние «почти тёмное, местами светлое». Как пишет официальное руководство — «вся поверхность должна следовать»,³ — половинчатый тёмный режим даёт худший опыт, чем фиксированный светлый. Для существующего актива реалистичная и объяснимая политика: выбрать 1, явно сказать «это приложение показывают светлым» и в момент перехода на .NET 10 переключиться на SetColorMode.

flowchart TB
    accTitle: Варианты WinForms по среде выполнения
    accDescr: На .NET 10 и новее берут SetColorMode; на .NET 9 тот же API с подавлением WFO5001; на .NET 8 и старше и .NET Framework либо явно фиксируют светлый режим, либо полностью поддерживают сами вплоть до общих элементов
    q{"Какая среда выполнения?"}
    q -->|.NET 10 и новее| n10["SetColorMode (System)"]
    q -->|.NET 9| n9["SetColorMode + подавить WFO5001"]
    q -->|.NET 8 и старше / .NET Framework| legacy{"Что делать?"}
    legacy -->|рекомендуется| fixed["Явно фиксировать светлый"]
    legacy -->|если готовы| full["Полностью поддержать самим"]
    full -.-> partial["Общие элементы остаются"]

Рис. 13: На средах выполнения без SetColorMode реалистичное умолчание — явно фиксировать светлый режим.

7. Реализация в WPF

7.1. .NET 9/10 ── тема Fluent и ThemeMode

В WPF .NET 9 поставляется новая тема по Fluent-дизайну Windows 11 с поддержкой светлого/тёмного и акцентного цвета. Применить её можно двумя способами: задать свойство ThemeMode или добавить словарь ресурсов PresentationFramework.Fluent в MergedDictionaries.⁸

Значения ThemeMode — четыре: Light / Dark / System / None (умолчание; прежняя тема Aero2). На Application действует на всё приложение, на Window — только на это окно.⁸

<Application x:Class="OrderEntry.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             StartupUri="MainWindow.xaml"
             ThemeMode="System">
</Application>

ThemeMode не только загружает словарь темы Fluent в ресурсы, но и прямо «управляет применением материала фона и тёмного режима к окну». То есть атрибутом DWM из главы 4 занимается сторона WPF. ThemeMode и Resources спроектированы так, чтобы работать синхронно: иначе окно тёмное, а элементы внутри светлые.¹⁰

flowchart TB
    accTitle: Что делает ThemeMode в WPF
    accDescr: ThemeMode=System загружает в ресурсы словарь темы Fluent по настройке Windows и вместе с этим управляет затемнением окна и применением материала фона
    tm["ThemeMode=System"] --> read["Прочитать настройку Windows"]
    read --> dict["Загрузить словарь Fluent в ресурсы"]
    read --> win["Затемнение окна и материал фона"]
    dict --> sync["Синхронизация с Resources, чтобы не было рассинхрона"]

Рис. 14: ThemeMode вместе управляет загрузкой словаря Fluent и затемнением окна.

Перед внедрением нужно знать две оговорки. Первая: чтение и запись ThemeMode из кода — экспериментальная функция; доступ даёт ошибку WPF0001. С подавлением можно писать Application.Current.ThemeMode = ThemeMode.Dark, но справочник API и в .NET 10 оставляет [Experimental("WPF0001")] и помечает, что «в будущем может быть удалено».⁸¹⁰ Вторая: поддержка стилей Fluent и в .NET 10 «в работе». В .NET 10 добавлены стили DatePicker, GridSplitter, GroupBox, TextBox и других и исправлены сбои, связанные с HighContrast,⁹ — иначе говоря, в Fluent .NET 9 их не было. Перед решением о внедрении на реальной машине проверьте, не ломаются ли используемые в бизнес-приложении элементы (особенно DataGrid и сторонние) под Fluent.

7.2. Следовать, оставаясь на прежней теме ── подмена ResourceDictionary

В WPF без Fluent (или на .NET 8 и старше и .NET Framework) стандартной поддержки тёмного режима нет. Системные цвета Win32 от настройки светлый/тёмный не меняются, поэтому ссылка на SystemColors WPF сама по себе не затемнит. Структура собственного следования такая.

1. В светлом Themes/Light.xaml и тёмном Themes/Dark.xaml определить цвета и кисти с теми же ключами.
2. Из XAML ссылаться через DynamicResource, например {DynamicResource App.WindowBackgroundBrush} (StaticResource фиксируется при загрузке и подмену не подхватывает).
3. По уведомлению SystemThemeWatcher из главы 5 подменять соответствующий словарь в MergedDictionaries. При теме контрастности любой словарь всё равно заменит триггер из 8.4 на системные цвета, поэтому оставляют светлый.

public static class AppTheme
{
    private static readonly Uri Light = new("pack://application:,,,/Themes/Light.xaml");
    private static readonly Uri Dark = new("pack://application:,,,/Themes/Dark.xaml");

    public static void Apply(ThemeState state)
    {
        var merged = Application.Current.Resources.MergedDictionaries;
        var current = merged.FirstOrDefault(d => d.Source == Light || d.Source == Dark);
        // Тёмный словарь только в тёмном состоянии. При теме контрастности отдать системным цветам (8.4)
        var next = new ResourceDictionary { Source = state == ThemeState.Dark ? Dark : Light };
        if (current is null)
        {
            merged.Add(next);
        }
        else
        {
            merged[merged.IndexOf(current)] = next; // подменить на том же месте
        }
    }
}

flowchart TB
    accTitle: Подмена словаря ресурсов в WPF
    accDescr: В светлом и тёмном словарях цвета с теми же ключами, XAML ссылается через DynamicResource, по уведомлению о смене темы словарь в MergedDictionaries подменяют — ссылки обновляются
    notify["Уведомление о смене темы"] --> swap["Подменить словарь в MergedDictionaries"]
    light["Light.xaml (те же ключи)"] --> swap
    dark["Dark.xaml (те же ключи)"] --> swap
    swap --> dyn["Ссылки DynamicResource обновляются"]
    static["Ссылка StaticResource"] -.-> stale["Остаётся значением на момент загрузки"]

Рис. 15: Если подменить словарь с теми же ключами, следуют только ссылки DynamicResource.

Шаблоны стандартных элементов (фон кнопки, цвет полосы прокрутки) несут цвета прежней темы, поэтому и здесь останутся места «собственные поверхности тёмные, стандартные элементы светлые». Оцените объём работы по переопределению стилей нужных элементов и сравните с внедрением Fluent или фиксированным светлым режимом.

7.3. Панель заголовка

Если используете ThemeMode, этим занимается WPF. Если следуете сами, оставаясь на прежней теме, задавайте атрибут DWM из OnSourceInitialized, как в 4.2, и задавайте снова по уведомлению SystemThemeWatcher.

8. Отрисовка при теме контрастности ── соблюдать пары системных цветов

8.1. Обнаружение и уведомление

В Win32 в SystemParametersInfo передают SPI_GETHIGHCONTRAST, получают структуру HIGHCONTRAST и проверяют бит HCF_HIGHCONTRASTON в dwFlags. При вызове нужно задать cbSize.¹¹²⁸ Microsoft называет это «единственным поддерживаемым способом проверить наличие высокой контрастности».¹²

bool IsContrastThemeActive()
{
    HIGHCONTRASTW hc{};
    hc.cbSize = sizeof(hc);
    if (!::SystemParametersInfoW(SPI_GETHIGHCONTRAST, sizeof(hc), &hc, 0))
    {
        // Не маскировать сбой умолчанием. Всплыть с кодом ошибки, чтобы была причина
        throw std::system_error(::GetLastError(), std::system_category(),
                                "SystemParametersInfo(SPI_GETHIGHCONTRAST)");
    }
    return (hc.dwFlags & HCF_HIGHCONTRASTON) != 0;
}

У каждой платформы есть свойство, которое оборачивает этот вызов.

Руководство по доступности WinForms требует проверять HighContrast при запуске и реагировать на изменения через UserPreferenceChanged.¹³ SystemParameters.HighContrast в WPF сопоставлен с SPI_GETHIGHCONTRAST и HCF_HIGHCONTRASTON,²⁹ смена статического свойства уведомляется через StaticPropertyChanged.³⁰ ThemeSettings в WinUI 3 создают, привязав к окну через CreateForWindowId, и подписываются на событие Changed; важно держать ссылку на объект, иначе событие остановится.³¹

flowchart TB
    accTitle: Пути обнаружения темы контрастности
    accDescr: SPI_GETHIGHCONTRAST Win32 — единственный поддерживаемый способ проверки; SystemInformation.HighContrast WinForms, SystemParameters.HighContrast WPF и ThemeSettings.HighContrast WinUI 3 — обёртки этого вызова с каждой платформы
    spi["SPI_GETHIGHCONTRAST (единственный способ проверки)"] --> wf["WinForms SystemInformation"]
    spi --> wpf["WPF SystemParameters"]
    spi --> winui["WinUI 3 ThemeSettings"]
    spi --> win32["Win32 прямой вызов"]

Рис. 16: Корень проверки — один Win32 API; у каждой платформы есть оборачивающее свойство.

8.2. Принципы отрисовки ── пары переднего плана и фона

«High contrast parameter» Microsoft называет три вещи, которые приложение должно делать, когда высокая контрастность включена.¹¹

1. Отобразить все цвета на одну пару переднего плана и фона. Через GetSysColor брать пару COLOR_WINDOWTEXT и COLOR_WINDOW или пару COLOR_BTNTEXT и COLOR_BTNFACE.
2. Убрать растровые изображения за текстом. Для пользователей, которым нужна высокая контрастность, это визуальная помеха.
3. Многоцветные изображения рисовать цветами переднего плана и фона, предназначенными для текста.

Ключ — «пара». Руководство с Windows 8 объясняет, что COLOR_HIGHLIGHTTEXT рассчитан на фон COLOR_HIGHLIGHT, а COLOR_WINDOWTEXT — на фон COLOR_WINDOW, и требует не задавать цвет текста жёстко и делать UI, который не зависит от применяемой темы, потому что пользователь настраивает цвета.¹² Пример того же руководства — «в Aero текст всегда чёрный, цвет выделения светло-голубой, а в High Contrast Black цвет выделения чёрный. Если взять системный цвет выделения, предполагая чёрный текст, получится чёрный текст на чёрном» — это и есть «пропал индикатор статуса» из начала статьи.

Руководство по темам контрастности Windows 11 сводит это соответствие в таблицу.¹

И прямо написано, чего не делать. Не использовать GrayText для пояснений и подсказок (только отключённое состояние), не использовать Hotlight ни для чего, кроме гиперссылок, не смешивать несовместимые передний план и фон, не выбирать цвет только по виду (пользователь реально меняет цвета). Фон страниц, панелей и всплывающих окон берут от SystemColorWindow как базы; соседние поверхности оказываются одного цвета, поэтому нужные границы отделяют рамкой только для темы контрастности (для всплывающих окон и диалогов рекомендуют 2px).¹

flowchart TB
    accTitle: Как ломается читаемость, когда пару нарушают
    accDescr: Если зашить «текст чёрный» и взять только системный цвет выделения для фона, в High Contrast Black цвет выделения чёрный — чёрный текст на чёрном. Если брать передний план и фон парой, читаемость остаётся, даже когда пользователь правит цвета
    assume["Зашить: текст чёрный"] --> hl["Только фон выделения — системный цвет выделения"]
    hl --> black["В High Contrast Black цвет выделения чёрный"]
    black --> broken["Чёрный текст на чёрном"]
    pair["Брать передний план и фон парой"] --> ok["Читаемо, даже если пользователь правит цвета"]
    edit["Пользователь правит цвета"] -.-> assume

Рис. 17: Если взять только одну сторону как системный цвет, возможен чёрный текст на чёрном; парой — читаемо и после правки цветов.

flowchart TB
    accTitle: Решение об отрисовке при теме контрастности
    accDescr: Если тема контрастности включена, отобразить цвета на пары системных цветов, убрать изображения за текстом, рисовать многоцветные изображения двумя цветами переднего плана и фона, не использовать жёстко заданные цвета
    on["Тема контрастности включена"] --> map["Отобразить цвета на пары"]
    on --> img["Убрать изображения за текстом"]
    on --> multi["Многоцветные рисунки двумя цветами"]
    on --> nohard["Не использовать жёстко заданные цвета"]

Рис. 18: Отрисовка при включённой теме контрастности сводится к отображению, опущению, двум цветам и отказу от жёсткого кода.

8.3. Реализация в WinForms

Стандартные элементы WinForms следуют системным цветам, если оставить ForeColor / BackColor по умолчанию. Переключают по проверке только места с собственными цветами и собственную отрисовку. Пример руководства: обычно метка жёлтым на синем, при высокой контрастности возвращают к SystemColors.Window / SystemColors.WindowText.¹³ К структуре палитры выше добавляют ветку для темы контрастности.

using Microsoft.Win32;

public partial class OrderForm : Form
{
    private readonly SynchronizationContext _ui;

    public OrderForm()
    {
        InitializeComponent();
        // Элемент уже создан, поэтому WindowsFormsSynchronizationContext на месте
        _ui = SynchronizationContext.Current
              ?? throw new InvalidOperationException("Создавайте на потоке UI.");
        ApplyColorScheme();
        SystemEvents.UserPreferenceChanged += OnUserPreferenceChanged;
    }

    private void ApplyColorScheme()
    {
        if (SystemInformation.HighContrast)
        {
            // Соблюсти пару, полностью отдать системным цветам, убрать изображение за текстом
            statusLabel.BackColor = SystemColors.Window;
            statusLabel.ForeColor = SystemColors.WindowText;
            headerPanel.BackgroundImage = null;
        }
        else
        {
            var p = AppPalette.Current; // светлая/тёмная палитра (глава 5)
            statusLabel.BackColor = p.PanelBackground;
            statusLabel.ForeColor = p.PanelForeground;
            headerPanel.BackgroundImage = Properties.Resources.HeaderPattern;
        }
    }

    private void OnUserPreferenceChanged(object? sender, UserPreferenceChangedEventArgs e)
    {
        // Это событие тоже не гарантирует приход на поток UI. Вернуться на UI и перепроверить без фильтра по категории
        _ui.Post(_ =>
        {
            if (IsDisposed) return;
            ApplyColorScheme();
        }, null);
    }

    // Статическое событие: если не отписать, форма утечёт. Отписывать в Dispose(bool),
    // который проходит и путь уничтожения без закрытия (если есть Dispose(bool) от дизайнера — писать туда)
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            SystemEvents.UserPreferenceChanged -= OnUserPreferenceChanged;
        }
        base.Dispose(disposing);
    }
}

Собственную отрисовку в OnPaint ведут системными кистями, соблюдая пары, вроде SystemBrushes.Window / SystemPens.WindowText; многоцветные рисунки вроде цветного кружка статуса заменяют рамкой цвета переднего плана и текстом («работа», «остановлено»). Отображение не одним цветом — то же, что критерий успеха 1.4.1 из предыдущей статьи.

flowchart TB
    accTitle: Ветка применения цветов в WinForms
    accDescr: При запуске и при каждом UserPreferenceChanged вызывают ApplyColorScheme; если SystemInformation.HighContrast истинно, отдают пары системных цветов и убирают фоновое изображение, иначе берут цвета из светлой/тёмной палитры
    start["Запуск / UserPreferenceChanged"] --> apply["ApplyColorScheme"]
    apply --> q{"SystemInformation.HighContrast?"}
    q -->|да| sys["Отдать пары SystemColors"]
    sys --> noimg["Убрать фоновое изображение"]
    q -->|нет| pal["Взять из светлой/тёмной палитры"]

Рис. 19: В WinForms при запуске и при каждом уведомлении вызывают одну обработку; при теме контрастности отдают системным цветам.

8.4. Реализация в WPF

SystemColors WPF автоматически обновляются при смене кисти, если ключ ресурса вроде WindowBrushKey ссылать через DynamicResource (статическая ссылка напрямую на WindowBrush не обновляется).³² Чтобы переключать вид только при теме контрастности, из DataTrigger ссылаются на значение SystemParameters.HighContrast. Но SystemParameters.HighContrast — статическое свойство и само по себе не живой источник привязки. Делают маленький прокси, который подписывается на StaticPropertyChanged, держит значение и уведомляет через INotifyPropertyChanged, и в Source указывают этот экземпляр.³⁰

public sealed class ThemeSettings : INotifyPropertyChanged
{
    public static ThemeSettings Instance { get; } = new();

    public bool IsHighContrast { get; private set; } = SystemParameters.HighContrast;
    public event PropertyChangedEventHandler? PropertyChanged;

    private ThemeSettings()
    {
        // Уведомление, когда меняется статическое свойство SystemParameters (заново берут SPI_GETHIGHCONTRAST)
        SystemParameters.StaticPropertyChanged += (_, e) =>
        {
            if (!string.IsNullOrEmpty(e.PropertyName)
                && e.PropertyName != nameof(SystemParameters.HighContrast)) return;
            IsHighContrast = SystemParameters.HighContrast;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsHighContrast)));
        };
    }
}

<!-- заранее объявить xmlns:local="clr-namespace:OrderEntry" -->
<Style x:Key="CardStyle" TargetType="Border">
    <Setter Property="Background" Value="{DynamicResource App.CardBackgroundBrush}"/>
    <Setter Property="BorderBrush" Value="{DynamicResource App.CardBorderBrush}"/>
    <Setter Property="BorderThickness" Value="1"/>
    <Style.Triggers>
        <DataTrigger Binding="{Binding Source={x:Static local:ThemeSettings.Instance}, Path=IsHighContrast}"
                     Value="True">
            <!-- Соблюсти пару: фон Window, рамка и текст WindowText. Граница потолще -->
            <Setter Property="Background"
                    Value="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"/>
            <Setter Property="BorderBrush"
                    Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"/>
            <!-- Наследовать и тексту внутри. Дочерние элементы с явным Foreground обрывают наследование -->
            <Setter Property="TextElement.Foreground"
                    Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"/>
            <Setter Property="BorderThickness" Value="2"/>
        </DataTrigger>
    </Style.Triggers>
</Style>

flowchart TB
    accTitle: Ссылки на системные цвета WPF и триггер темы контрастности
    accDescr: Ссылка DynamicResource на ключ ресурса SystemColors автоматически следует смене кисти; триггер, привязанный к IsHighContrast прокси, который подписан на StaticPropertyChanged, реагирует на переключение во время работы и переключает на цвета с соблюдением пары. Прямая ссылка на WindowBrush не обновляется
    key["WindowBrushKey через DynamicResource"] --> auto["Автоматически следует смене кисти"]
    spc["StaticPropertyChanged"] --> proxy["IsHighContrast прокси"]
    proxy --> trig["Срабатывает DataTrigger"]
    trig --> pair["Переключить на цвета с соблюдением пары"]
    direct["Прямая ссылка на WindowBrush"] -.-> stale["Не обновляется"]

Рис. 20: WPF следует переключению во время работы динамической ссылкой на ключ ресурса и привязкой к прокси, который ретранслирует смену статического свойства.

Даже при теме Fluent, учитывая исправление сбоев HighContrast в .NET 10,⁹ включайте проверку работы при теме контрастности в условия внедрения.

8.5. Реализация в WinUI 3

В WinUI 3 стандартные элементы с самого начала следуют светлой/тёмной теме и теме контрастности; собственные цвета приложения определяют в ResourceDictionary.ThemeDictionaries ключами Default (тёмный), Light и HighContrast. В HighContrast цвета не задают жёстко, а ссылаются через ThemeResource на динамические системные цвета вроде SystemColorWindowColor. У пользовательского элемента с Light/Dark обязательно готовят и HighContrast; HighContrast — ключ запасного варианта, когда не найдена другая именованная тема высокой контрастности.³³¹

<ResourceDictionary.ThemeDictionaries>
    <ResourceDictionary x:Key="Default">
        <SolidColorBrush x:Key="App.CardBackgroundBrush" Color="#2B2B2B"/>
    </ResourceDictionary>
    <ResourceDictionary x:Key="Light">
        <SolidColorBrush x:Key="App.CardBackgroundBrush" Color="#F3F3F3"/>
    </ResourceDictionary>
    <ResourceDictionary x:Key="HighContrast">
        <SolidColorBrush x:Key="App.CardBackgroundBrush"
                         Color="{ThemeResource SystemColorWindowColor}"/>
    </ResourceDictionary>
</ResourceDictionary.ThemeDictionaries>

Ещё в WinUI есть механизм HighContrastAdjustment, по умолчанию включённый. Он принудительно ставит белый текст и чёрный фон выделения, чтобы сохранить контраст; если словарь темы правильно использует системные цвета, руководство рекомендует поставить None и пропустить свои стили.¹

flowchart TB
    accTitle: Разрешение ThemeDictionaries WinUI
    accDescr: По текущей теме выбирается один из словарей Default (тёмный), Light, HighContrast; в HighContrast динамические системные цвета ссылают через ThemeResource. HighContrast — ключ запасного варианта, когда нет именованной темы высокой контрастности
    theme{"Какая сейчас тема?"}
    theme -->|тёмная| def["Словарь Default"]
    theme -->|светлая| light["Словарь Light"]
    theme -->|тема контрастности| hc["Словарь HighContrast"]
    hc --> sysc["SystemColor через ThemeResource"]
    hc -.-> fb["Запасной вариант, когда нет именованной темы"]

Рис. 21: В WinUI словарь по теме выбирается автоматически; словарь HighContrast ссылается на системные цвета.

9. Поддержка тёмного режима не заменяет поддержку доступности

Сообщать «сделали поддержку доступности», имея в виду поддержку тёмного режима, — ошибка. Связь такая.

• К тёмной палитре критерии коэффициента контрастности применяются так же. Критерий успеха WCAG 1.4.3 требует 4,5:1 для текста и 3:1 для крупного текста; тёмный фон это не меняет.¹⁴ Тёмный дизайн с текстом среднего серого на тёмно-сером фоне несёт ту же проблему, что светлый «бледно-серый на белом».
• Избегать чистых чёрного и белого — дизайн Windows 11. Лучшие практики Microsoft объясняют, что Windows 11 ушёл от чистых белого и чёрного к тонам, более щадящим для глаз.³⁴ Наоборот, фон #000000 в тёмном режиме у части людей вызывает жалобы на слишком сильный контраст со светлым текстом (ореол).
• Учёт разнообразия цветового зрения нужен независимо от темы. Цветовое руководство Microsoft требует не делать цвет основным средством передачи и не делать сочетание красного и зелёного единственным отличием.³⁵¹⁵
• Тема контрастности — отдельное требование от тёмного режима. Как в главе 2, пока тема контрастности включена, тёмный режим недоступен: какой бы совершенной ни была тёмная поддержка, до пользователей темы контрастности она не доходит.

flowchart TB
    accTitle: Связь тёмного режима и доступности
    accDescr: Поддержка тёмного режима — учёт предпочтения и среды; требования доступности — коэффициент контрастности, передача не одним цветом, поддержка тем контрастности — нужно выполнять отдельно, независимо от темы
    dark["Поддержка тёмного режима"] --> pref["Учёт предпочтения и среды"]
    a11y["Доступность"] --> ratio["Коэффициент контрастности 4,5:1"]
    a11y --> sole["Не одним цветом"]
    a11y --> ct["Поддержка тем контрастности"]
    dark -.->|не заменяет| a11y

Рис. 22: Поддержка тёмного режима — учёт предпочтения и среды; требования доступности выполняют отдельно.

С другой стороны, работа главы 5 «собрать цвета в одном месте» — фундамент обоих. Если палитра в одном месте, можно перечислить объекты для измерения коэффициента контрастности в светлом и в тёмном и в том же месте написать ветку для темы контрастности. Самый выгодный порядок вложений: по случаю тёмной поддержки собрать палитру и заодно проверить коэффициент контрастности и тему контрастности.

10. Как выбрать политику ── рекомендации по типу приложения

flowchart TB
    accTitle: Путь существующего актива к тёмной поддержке
    accDescr: Существующий актив сначала явно фиксирует светлый режим, обязательно заканчивает поддержку тем контрастности, готовит собранную палитру, переходит на .NET 10 и переключается на SetColorMode или ThemeMode. Половинчатая тёмная поддержка даёт худший опыт, чем фиксированный светлый, поэтому этим путём не идут
    now["Явно фиксировать светлый (сейчас)"] --> ct["Поддержка тем контрастности (обязательно)"]
    ct --> pal["Собрать палитру (подготовка)"]
    pal --> mig["Переход на .NET 10"]
    mig --> dark["Переключение на SetColorMode / ThemeMode"]
    now -.->|не идут| half["Половинчатая тёмная поддержка"]
    half -.-> worse["Хуже, чем фиксированный светлый"]

Рис. 23: Существующий актив начинают с фиксированного светлого, проходят поддержку тем контрастности и сбор палитры и к тёмной поддержке переходят при миграции на .NET 10.

«Фиксированный светлый режим» — не поражение. Это само умолчание Windows и документированное поведение. Последовательный светлый для пользователя куда лучше, чем половинчатый тёмный с «тёмной только панелью заголовка» и «светлой только полосой прокрутки». Но одну только поддержку тем контрастности «фиксировать» нельзя. Это область разумного приспособления из предыдущей статьи: не предпочтение темы, а вопрос, можно ли пользоваться.

11. Контрольный список проверки

После реализации проверяют на реальной машине в таком порядке. Все переключения — из экрана параметров, за десятки секунд.

1. Переключить светлый/тёмный во время работы. В «Параметры > Персонализация > Цвета» сменить режим и проверить, следуют ли и панель заголовка, и клиентская область, либо что поведение «вступит в силу при следующем запуске» (у SetColorMode WinForms не следует).
2. Вызвать пересоздание дескриптора. В WinForms во время работы переключить ShowInTaskbar и проверить, сохранился ли атрибут панели заголовка.
3. Прогнать все четыре темы контрастности. Переключить Left Alt+Left Shift+PrintScreen и на Aquatic, Desert, Dusk и Night sky проверить, читаются ли текст, рамки, выделенная строка, отключённые пункты и ссылки.¹
4. Отредактировать цвета темы контрастности. Пользователь реально меняет цвета. Поставить фону экстремальный цвет и выжечь оставшийся жёсткий код.
5. Смотреть журнал. На поддерживаемой ОС записан ли сбой DwmSetWindowAttribute или SystemParametersInfo; на Windows 10 ниже сборки 22000 атрибут DWM не вызывается и запуск остаётся светлым.
6. Измерить коэффициент контрастности. В светлом и в тёмном проверить сочетания цвета текста и фона палитры на 4,5:1.¹⁴

flowchart TB
    accTitle: Порядок проверки поддержки темы
    accDescr: На реальной машине проверяют в порядке: переключение светлый/тёмный во время работы, пересоздание дескриптора, четыре темы контрастности, правка цветов темы, журнал сбоев, измерение коэффициента контрастности
    s1["Переключить светлый/тёмный во время работы"] --> s2["Пересоздание дескриптора"]
    s2 --> s3["Четыре темы контрастности"]
    s3 --> s4["Отредактировать цвета темы"]
    s4 --> s5["Проверить журнал сбоев"]
    s5 --> s6["Измерить коэффициент контрастности"]

Рис. 24: Проверку начинают с переключения настроек и закрывают журналом и коэффициентом контрастности.

12. Итог

• У тем Windows две оси — «светлый/тёмный» и «темы контрастности»; пока вторая включена, тёмный режим недоступен. Сначала проверяют тему контрастности.
• Белая панель заголовка у существующего приложения — умолчание ради совместимости; если передать TRUE в DWMWA_USE_IMMERSIVE_DARK_MODE (DwmSetWindowAttribute, значение 20, Windows 11 сборка 22000 и новее), при тёмной системе рисуется тёмным. Задают при каждом создании HWND, сбой пишут в журнал.
• Текущий режим определяют по яркости цвета переднего плана UISettings.GetColorValue, замечают изменение через ColorValuesChanged, возвращаются на поток UI и перерисовывают. Цвета держат в одном месте.
• WinForms — Application.SetColorMode(SystemColorMode.System) на .NET 9/10. Три ограничения: только Windows 11, выключен при теме контрастности, не следует за сменой во время работы; плюс ApplyThemingImplicitly у собственных элементов.
• WPF — ThemeMode="System" на .NET 9/10. Операции из кода экспериментальны, Fluent в работе — внедрять после оценки. На прежней теме — подмена словаря + DynamicResource.
• При теме контрастности определяют семейством SPI_GETHIGHCONTRAST, отображают цвета на пары системных цветов, убирают изображения за текстом, многоцветные рисунки двумя цветами. GrayText — отключённое состояние, Hotlight — только ссылки.
• Тёмная поддержка не заменяет поддержку доступности. И в тёмном 4,5:1, не одним цветом, поддержку тем контрастности делают отдельно.
• Для существующего актива реалистичный ответ — явно «фиксированный светлый режим»; одну только поддержку тем контрастности фиксировать нельзя.

Рекомендуемый первый шаг: взять один основной экран, сначала включить тему контрастности Left Alt+Left Shift+PrintScreen и посмотреть, теми же клавишами вернуться и затем переключить цветовую настройку Windows на тёмную (пока тема контрастности включена, тёмный режим недоступен, поэтому два пробуют отдельно). За несколько минут станет видно, «где приложение держит цвета».

Похожие статьи

• Доступность приложений Windows: UI Automation и разумное приспособление
• WinRT — это COM ── IInspectable, .winmd, языковые проекции и почему WinUI до сих пор стоит на двоичном контракте
• Безопасный вызов Win32 API из C# — практическое руководство по P/Invoke (DllImport / LibraryImport / CsWin32)
• WPF и WinForms: async/await и поток UI
• Поддержка высокого DPI в WinForms — почему на 4K размывается или ломается макет
• Высокий DPI в WPF — почему «к DPI должен быть готов», а на деле всё размывается
• WinForms, WPF или WinUI: практическая таблица выбора

Смежные области консультирования

Компания KomuraSoft LLC занимается поддержкой тёмного режима в бизнес-приложениях WinForms/WPF (сбор палитры, оценка перехода на SetColorMode / ThemeMode в .NET 9/10, встраивание атрибута DWM), диагностикой и исправлением поломки отображения при темах контрастности, консультациями по следованию теме в активе Win32/MFC. Можно начинать со стадии «переключили на тёмный режим — пришли жалобы сотрудников».

• Разработка приложений для Windows
• Технические консультации и ревью дизайна
• Связаться с нами

Справочные ссылки

Похожие статьи

Недавние статьи с теми же тегами помогут подробнее изучить близкие темы.

Связанные темы

Эти страницы показывают тему статьи в более широком контексте услуг и решений.

Услуги по этой теме

Статья напрямую связана со следующими услугами.

Частые вопросы

Вопросы, которые часто возникают при консультациях по теме статьи.

Переключили Windows в тёмный режим, а панель заголовка нашего WinForms-приложения осталась белой. Почему?

Потому что Windows не знает, поддерживает ли приложение тёмный режим, и ради совместимости по умолчанию считает все окна светлыми. Неклиентскую область, включая панель заголовка, рисует диспетчер окон рабочего стола (DWM); рамка становится тёмной, когда система тёмная, только после того, как приложение передаст TRUE в DWMWA_USE_IMMERSIVE_DARK_MODE (значение 20) через DwmSetWindowAttribute. Поддержка этого атрибута документирована для Windows 11 сборки 22000 и новее. Если в WinForms на .NET 9 и новее вызывать Application.SetColorMode или в WPF на .NET 9 и новее использовать ThemeMode, этот вызов берёт на себя платформа, так что самим его делать нужно только в приложениях на .NET 8 и старше, .NET Framework или Win32/MFC. Тёмная панель заголовка при белой клиентской области выглядит хуже, не лучше. Включайте этот атрибут, только когда готовы перекрасить всё приложение в тёмное.

Тёмный режим и темы контрастности (высокая контрастность) — одно и то же?

Нет. Светлый/тёмный — это цветовой режим в «Параметры > Персонализация > Цвета»: широкая палитра, которая меняет местами яркость переднего плана и фона. Тему контрастности выбирают в «Параметры > Специальные возможности > Темы контрастности»: ограниченная палитра с коэффициентом контрастности примерно 7:1 и выше (четыре встроенные темы Aquatic, Desert, Dusk и Night sky плюс цвета, которые пользователь отредактировал). Документация Microsoft прямо просит их не путать; пока тема контрастности включена, тёмный режим недоступен (SetColorMode в WinForms в это время тёмный режим не даёт, а RequestedTheme в XAML система перезаписывает). В реализации сначала проверяйте, включена ли тема контрастности, и если да — полностью отдайте цвета системным; иначе выбирайте светлую или тёмную палитру. Это порядок приоритета.

Какой самый короткий путь включить тёмный режим в приложении WinForms?

На .NET 9 и новее самый короткий путь — вызвать Application.SetColorMode(SystemColorMode.System) в Program.cs до Application.Run. В .NET 9 это была экспериментальная функция, поэтому в файле проекта нужно было подавить WFO5001; с .NET 10 подавление не нужно. Вызов SetColorMode переключает SystemColors на альтернативный набор для тёмного режима, и стандартные элементы рисуются по нему. Есть три оговорки. Первая: тёмный режим доступен только на Windows 11 и новее и выключен, пока включена тема контрастности. Вторая: даже с SystemColorMode.System приложение не следует за сменой настройки Windows во время работы (изменение вступит в силу при следующем запуске). Третья: если элемент с собственной отрисовкой использует общие элементы управления Win32 вроде полос прокрутки, нужно переопределить CreateParams и вызвать SetStyle(ControlStyles.ApplyThemingImplicitly, true) до base.CreateParams (в конструкторе уже поздно).

Что сделать в приложении WPF, чтобы оно следовало тёмному режиму?

В WPF на .NET 9 и новее поставляется новая тема по Fluent-дизайну Windows 11: достаточно написать ThemeMode="System" на элементе Application в App.xaml — загрузится Fluent-тема, совпадающая со светлой/тёмной настройкой Windows. ThemeMode также управляет затемнением окна (панелью заголовка) и применением материала фона. Однако чтение и запись свойства ThemeMode из кода в .NET 10 всё ещё экспериментальны (WPF0001), а сами стили Fluent в документации .NET 10 описаны как «ещё в работе». Перед внедрением в бизнес-приложение оцените, не ломаются ли используемые элементы под Fluent. Если остаётесь на прежней теме (то же для .NET 8 и старше и для .NET Framework), подготовьте светлый и тёмный ResourceDictionary, подменяйте их в MergedDictionaries, из XAML ссылайтесь через DynamicResource, а смену отслеживайте через UISettings.ColorValuesChanged. Для панели заголовка в SourceInitialized возьмите HWND из WindowInteropHelper и вызовите DwmSetWindowAttribute.

Почему при теме контрастности (высокой контрастности) текст пропадает или становится нечитаемым?

Типичные причины — жёстко заданные цвета или нарушенная пара переднего плана и фона системных цветов. В теме контрастности пользователь свободно правит цвета фона, текста, ссылок и прочего, поэтому все предпосылки вроде «текст будет чёрным» или «выделенная строка будет светло-голубой» рушатся. Например, если зафиксировать только фон как #E6E6E6, в части тем передний план станет белым, и белый текст на светло-сером не читается. Принципов три. Определяйте состояние через SPI_GETHIGHCONTRAST (SystemInformation.HighContrast в WinForms, SystemParameters.HighContrast в WPF); замените все цвета правильными парами системных цветов (WindowText с Window, ButtonText с ButtonFace, HighlightText с Highlight); уберите изображения за текстом и многоцветную графику, рисуя только цветами переднего плана и фона. GrayText нельзя использовать ни для чего, кроме отключённого состояния, Hotlight — ни для чего, кроме гиперссылок. Об изменениях сообщают WM_SYSCOLORCHANGE и WM_THEMECHANGED (в .NET — SystemEvents.UserPreferenceChanged): там пересчитайте цвета и перерисуйте.

Об авторе

Страница с профилем автора статьи.

Го Комура

Представитель KomuraSoft LLC

Специализируется на разработке программного обеспечения для Windows, техническом консалтинге и расследовании сбоев, особенно в проектах с унаследованными системами и трудно воспроизводимыми ошибками.