4.11. Особенности разработки десктопных приложений

В РАЗРАБОТКЕНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНО

Разработчику Архитектору Инженеру

Особенности разработки десктопных приложений

Разработка десктопного программного обеспечения предъявляет специфические требования, отличающие её от веб- и мобильной разработки. Эти особенности касаются как архитектурных решений, так и практик обеспечения качества, безопасности и удобства использования.

Многопоточность и реактивность

Многопоточность и реактивность интерфейса — одна из центральных проблем. Пользовательский интерфейс почти всегда работает в едином потоке — UI-потоке (main thread, dispatcher thread). Любая длительная операция, выполняемая в этом потоке (чтение большого файла, сетевой запрос, сложный расчёт), блокирует обработку сообщений ОС, что приводит к «зависанию» приложения: окно перестаёт перерисовываться, не реагирует на ввод, отображается индикатор «не отвечает». Поэтому критически важно выносить все тяжёлые операции в фоновые потоки или асинхронные задачи.

Современные фреймворки предлагают несколько подходов:

В .NET: async/await с Task, BackgroundWorker (устаревший), ThreadPool.QueueUserWorkItem, Task.Run. Важно помнить, что обновление UI из фонового потока требует маршалинга: в WinForms — Control.Invoke, в WPF/MAUI — Dispatcher.Invoke или Dispatcher.BeginInvoke.
В Java: SwingWorker, ExecutorService, CompletableFuture. Для обновления UI из фонового потока — SwingUtilities.invokeLater.
В Qt: QThread, QtConcurrent, сигналы и слоты с Qt::QueuedConnection.
В Electron: Web Workers для изоляции тяжёлых вычислений от основного процесса рендеринга.

Архитектурные паттерны, такие как MVVM (Model-View-ViewModel), явно проектируются с учётом асинхронности: ViewModel содержит асинхронные команды и свойства, изменения которых уведомляют View через механизм привязки данных, автоматически маршалируя обновления в UI-поток.

Ресурсы

Работа с локальными ресурсами требует аккуратности. Доступ к файловой системе, реестру (Windows), переменным окружения, аппаратным устройствам должен быть:

Безопасным: проверка существования файлов/директорий перед открытием, обработка исключений IOException, UnauthorizedAccessException.
Переносимым: использование кроссплатформенных API для путей (Path.Combine в .NET, os.path.join в Python, QDir::separator() в Qt), а не жёстко закодированных строк вроде C:\Users\... или /home/user/....
Изолированным: хранение пользовательских данных в стандартных местах — AppData/LocalAppData (Windows), ~/Library/Application Support (macOS), ~/.config/~/.local/share (Linux XDG Base Directory Specification). Это гарантирует совместимость с политиками безопасности и возможностью работы в многопользовательских системах.

Отладка и профилирование

Отладка и профилирование десктопных приложений сложнее, чем веб-приложений, из-за прямого доступа к «железу» и отсутствия единых инструментов. Стандартный набор включает:

Встроенные отладчики в IDE (Visual Studio, IntelliJ IDEA, Qt Creator) с возможностью пошагового выполнения, точек останова, анализа стека вызовов.
Профилировщики производительности: .NET — PerfView, dotTrace; Java — VisualVM, JProfiler; C++ — VTune, Valgrind (Linux), Instruments (macOS). Они позволяют выявлять узкие места: избыточные аллокации памяти, блокировки потоков, неэффективные запросы к диску.
Логирование — обязательная практика. Использование структурированных логгеров (Serilog, NLog, log4j, spdlog) с уровнями (Debug, Info, Warn, Error), ротацией файлов, возможностью включения детального трейса по запросу пользователя (например, через флаг --verbose). Логи должны содержать контекст (имя потока, временные метки с микросекундами), но не персональные данные.

Локализация

Локализация и интернационализация — необходимость для выхода на международные рынки. Это комплексная задача:

Вынесение всех строк в ресурсы (.resx в .NET, .properties в Java, .qm в Qt, JSON в Electron).
Поддержка разных форматов дат, времени, чисел, валют через системные локали (CultureInfo в .NET, java.time.format в Java).
Адаптация интерфейса под языки с правосторонним письмом (RTL — Arabic, Hebrew): фреймворки вроде Qt и WPF поддерживают автоматическую зеркальную перестройку компоновки при смене FlowDirection.
Учёт различий в длине строк: английский текст часто короче немецкого или русского, что ломает фиксированные размеры контролов. Использование адаптивных контейнеров (Grid, DockPanel, ConstraintLayout) вместо абсолютного позиционирования.
Тестирование с «псевдолокализацией» — искусственным удлинением строк и заменой символов (например, MainMenu → [!!! Mäîñ Mëñú !!!]), чтобы выявить жёстко закодированные строки и проблемы компоновки на раннем этапе.

Доступность

Доступность (Accessibility) — требование законодательства (например, Section 508 в США, EN 301 549 в ЕС) и этики. Десктопные фреймворки предоставляют API для интеграции со вспомогательными технологиями:

В Windows — Microsoft UI Automation (UIA) и старый MSAA. Элементы управления должны предоставлять свойства: Name, ControlType, IsEnabled, Value, а также поддерживать шаблоны поведения (Invoke, ExpandCollapse, Selection).
В macOS — Accessibility API и VoiceOver.
В Linux — AT-SPI (Assistive Technology Service Provider Interface).
Разработчик обязан:
- Устанавливать осмысленные AutomationProperties.Name (WPF) или AccessibleName (WinForms/Qt).
- Обеспечивать полную клавиатурную навигацию (Tab-индекс, горячие клавиши).
- Поддерживать масштабирование интерфейса (DPI-awareness в Windows, NSHighResolutionCapable в macOS).
- Избегать передачи информации только через цвет (для дальтоников).
  Проверка проводится с помощью инструментов: Accessibility Insights (Windows), Xcode Accessibility Scanner (macOS), orca (Linux).

Безопасность

Безопасность — критический аспект, особенно учитывая привилегированный доступ десктопных приложений. Основные практики:

Принцип минимальных привилегий: приложение должно запрашивать только необходимые разрешения (UAC-запрос в Windows, sandbox в Flatpak/Snap, явные разрешения в .desktop-файлах Linux).
Защита от DLL-инъекций (Windows): использование SetDefaultDllDirectories и явного указания путей загрузки, проверка цифровой подписи загружаемых библиотек.
Безопасное хранение учётных данных: использование системных хранилищ — Windows Credential Manager, macOS Keychain, libsecret (Linux), а не открытых текстовых файлов.
Валидация всех внешних данных: файлов, аргументов командной строки, сетевого ввода — чтобы предотвратить инъекции, переполнения буферов, path traversal.
Обновление зависимостей: регулярный аудит используемых библиотек через dotnet list package --vulnerable, OWASP Dependency-Check, npm audit, так как уязвимости в сторонних компонентах (например, в OpenSSL, libpng) могут компрометировать всё приложение.

Обзор популярных решений и фреймворков

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

.NET-экосистема (C#, F#)

Windows Forms (WinForms)
Унаследован от .NET Framework 1.0 (2002), построен на обёртке над Win32 API. Каждый контрол — это нативное HWND-окно.
Преимущества: максимальная производительность, минимальные накладные расходы, глубокая интеграция с Windows, огромная база существующих приложений и знаний, простота для небольших утилит.
Ограничения: отсутствие современных UI-возможностей (анимации, шейдеры, адаптивный дизайн), трудности с кастомизацией внешнего вида, отсутствие официальной поддержки не-Windows платформ (хотя через Mono возможна ограниченная кроссплатформенность).
Статус: поддерживается в .NET 5+, но развитие заморожено; рекомендуется для поддержки legacy-систем или простых внутренних инструментов.
WPF (Windows Presentation Foundation)
Появился в .NET Framework 3.0 (2006), использует DirectX для рендеринга, декларативный XAML, привязки данных, стили, шаблоны, анимации.
Преимущества: богатый UI, поддержка векторной графики, масштабирование без потерь, чёткое разделение логики и представления (MVVM), мощная система привязок и команд.
Ограничения: только Windows, высокая сложность для простых задач, утечки памяти при неправильном управлении привязками, замедление развития (последнее крупное обновление — .NET 6).
Статус: стабильно поддерживается, но Microsoft рекомендует MAUI для новых кроссплатформенных проектов.
.NET MAUI (Multi-platform App UI)
Эволюция Xamarin.Forms, включена в .NET 6+ (2022), единый код для Windows, macOS, iOS, Android.
Преимущества: настоящая кроссплатформенность, единая кодовая база, нативный внешний вид на каждой платформе (через Handlers), поддержка современных практик (MVVM, DI, реактивность через CommunityToolkit.Mvvm).
Ограничения: молодой фреймворк, нестабильность API в ранних версиях, сложности с глубокой кастомизацией UI (требуется написание платформозависимого кода через partial classes или effects), меньшая производительность по сравнению с нативными решениями для сложных сценариев.
Статус: активно развивается, стратегическое направление Microsoft для кроссплатформенной разработки.
Avalonia UI
Сообщественный кроссплатформенный фреймворк с синтаксисом, близким к WPF/XAML.
Преимущества: WPF-подобный опыт разработки, поддержка Windows/macOS/Linux/WebAssembly, Skia-рендеринг (обеспечивает единый внешний вид), активное сообщество.
Ограничения: меньшая зрелость экосистемы (меньше готовых контролов и инструментов), зависимость от энтузиастов, неофициальная поддержка от Microsoft.
Статус: перспективное решение для кроссплатформенных WPF-миграций.

Java

Swing
Входит в JDK с 1998 года, построен на AWT, «лёгкие» компоненты (рисуются Java-кодом, не HWND).
Преимущества: кроссплатформенность «из коробки», огромное количество готовых компонентов, стабильность.
Ограничения: устаревший внешний вид («металлический» стиль), сложность кастомизации, отсутствие поддержки современных UI-тенденций, многопоточность требует строгого соблюдения EDT (Event Dispatch Thread).
Статус: поддерживается, но не развивается; подходит для корпоративных инструментов с низкими требованиями к UX.
JavaFX
Замена Swing, выделен в отдельный проект (OpenJFX), декларативный FXML, CSS-стилизация, аппаратное ускорение.
Преимущества: современный внешний вид, поддержка анимаций, 3D, веб-вью, кроссплатформенность (Windows/macOS/Linux), хорошая производительность.
Ограничения: необходимость поставки runtime вместе с приложением (jlink/jpackage решают это), меньшее количество готовых enterprise-компонентов по сравнению со Swing.
Статус: основное направление для новых Java-десктопных проектов.

C++/Qt

Qt
Кроссплатформенный фреймворк с 1995 года, C++ API, QML для декларативного UI.
Преимущества: высочайшая производительность, глубокая интеграция с ОС (нативные диалоги, уведомления), огромная библиотека (сети, БД, мультимедиа, 3D), Qt Creator как полноценная IDE, поддержка embedded.
Ограничения: коммерческая лицензия для проприетарных проектов (LGPL требует динамической линковки и предоставления возможности замены Qt), большой размер runtime, сложность для новичков.
Статус: промышленный стандарт для высоконагруженных приложений (AutoCAD, VLC, VirtualBox).

JavaScript/TypeScript

Electron
Комбинация Chromium и Node.js, UI на HTML/CSS/JS.
Преимущества: максимальная скорость разработки для веб-разработчиков, огромная экосистема npm, кроссплатформенность.
Ограничения: высокое потребление памяти (каждое окно — отдельный процесс Chromium), размер дистрибутива (сотни МБ), «ненативное» поведение UI (проблемы с горячими клавишами, системными меню, DPI), уязвимости из-за обновления Chromium.
Статус: доминирует в кроссплатформенных утилитах (VS Code, Slack, Discord), но подвергается критике за ресурсоёмкость.
Tauri
Альтернатива Electron: WebView2 (Windows), WebKit (macOS), WebKitGTK (Linux) + Rust-бэкенд.
Преимущества: минимальный размер (десятки МБ), низкое потребление памяти, безопасность (бэкенд на Rust, строгая модель разрешений), обновляемость через системные пакетные менеджеры.
Ограничения: молодой проект, меньшая зрелость инструментов, необходимость знания Rust для сложной логики.
Статус: быстро набирает популярность как «лёгкий Electron».

Архитектурные паттерны в десктопной разработке

Выбор архитектурного паттерна определяет масштабируемость, тестируемость и сопровождаемость десктопного приложения. В отличие от веб-разработки, где доминирует MVC, десктопные приложения чаще используют паттерны, ориентированные на работу с состоянием, привязками данных и отделением логики представления от бизнес-правил.

MVC

MVC (Model-View-Controller) — исторически первый паттерн, предложенный в Smalltalk-80.

Model — инкапсулирует данные и бизнес-логику.
View — отображает данные и перехватывает ввод пользователя.
Controller — посредник: получает события от View, изменяет Model, обновляет View.

В десктопной среде MVC применялся в ранних Java-приложениях (Swing) и некоторых C++/Qt проектах. Его слабость — тесная связь между View и Controller: View часто содержит ссылки на Controller, что затрудняет повторное использование компонентов и усложняет тестирование UI без запуска графической подсистемы. В современной десктопной разработке MVC почти не используется в чистом виде.

MVP

MVP (Model-View-Presenter) — улучшение MVC, популяризированное в .NET (особенно WinForms).

Model — как в MVC.
View — пассивный интерфейс: только отображение и маршрутизация событий в Presenter. Не содержит логики.
Presenter — содержит всю логику представления: обрабатывает события View, работает с Model, обновляет View через его интерфейс.

View не знает о Presenter’е напрямую, а реализует интерфейс (например, IUserView), который Presenter использует для обновления. Это позволяет писать unit-тесты для Presenter’а без GUI. Однако ручное управление привязками («view.UpdateName(model.Name)») делает код объёмным и подверженным ошибкам при изменении интерфейса.

MVVM

MVVM (Model-View-ViewModel) — современный стандарт для WPF, UWP, MAUI, Avalonia, JavaFX (с библиотеками вроде mvvmFX).

Model — данные и бизнес-логика.
View — XAML/FXML/QML-разметка с привязками к свойствам ViewModel. Пассивна: не содержит кода логики.
ViewModel — адаптер между Model и View: предоставляет данные в форме, удобной для отображения (например, FormattedDate вместо DateTime), команды (ICommand), уведомления об изменениях (INotifyPropertyChanged).

Преимущества MVVM:

Чёткое разделение ответственностей.
Поддержка привязок данных «из коробки»: изменения в ViewModel автоматически отражаются во View и наоборот.
Тестируемость: ViewModel — обычный класс без зависимостей от UI, легко покрывается unit-тестами.
Поддержка дизайнеров: View можно редактировать в инструментах вроде Blend без касания логики.

Критические требования к реализации:

ViewModel должен быть неизменяемым по отношению к View: View только читает свойства и вызывает команды, но не модифицирует состояние ViewModel напрямую.
Использование асинхронных команд (AsyncRelayCommand, IAsyncCommand) для предотвращения блокировки UI.
Управление жизненным циклом: отписка от событий, отмена фоновых задач при закрытии View, чтобы избежать утечек памяти.

Clean Architecture / Onion Architecture

Эти подходы фокусируются на независимости от фреймворков и инфраструктуры. Приложение делится на концентрические слои:

Entities (Business Rules) — чистые объекты домена, не зависящие от внешнего мира.
Use Cases (Application Business Rules) — сценарии использования, оркестрирующие Entities.
Interface Adapters — ViewModel, контроллеры, сериализаторы — преобразуют данные между Use Cases и внешними системами.
Frameworks & Drivers — UI, БД, внешние API.

В десктопном контексте Clean Architecture позволяет легко заменить WinForms на WPF или перенести логику в веб-сервис, так как ядро приложения остаётся неизменным. Однако накладные расходы на абстракции оправданы только в средних и крупных проектах.

Выбор паттерна зависит от масштаба:

Для простых утилит (конвертер единиц, калькулятор) допустима монолитная архитектура без разделения.
Для корпоративных приложений (ERP-модули, десктопные клиенты к API) — MVVM + Clean Architecture.
Для высокопроизводительных приложений (CAD, редакторы видео) — MVP или кастомная архитектура с минимальными абстракциями для снижения накладных расходов.

Тестирование десктопных приложений

Тестирование десктопного ПО требует многоуровневого подхода, учитывающего как логику, так и специфику взаимодействия с ОС.

Unit-тесты — основа качества. Охватывают Model, ViewModel, сервисы, утилиты.

Требования: изоляция от UI, файловой системы, сети (через моки/стабы).
Фреймворки: xUnit/NUnit (C#), JUnit/TestNG (Java), pytest (Python), Google Test (C++).
Особенности: тестирование асинхронных методов (await Task в C#, CompletableFuture в Java), обработка исключений, валидация состояний.

Интеграционные тесты — проверяют взаимодействие компонентов:

Model + репозиторий (работа с SQLite/PostgreSQL в памяти).
ViewModel + сервис (имитация сетевых вызовов через HttpClient mock).
Используются те же фреймворки, что и для unit-тестов, но с более сложными фикстурами.

UI-тесты — наиболее сложный и хрупкий слой. Цель: проверить корректность отображения, поведения элементов, навигации.

Подходы:
- На уровне автоматизации ОС: Microsoft UI Automation (WinAppDriver), Apple Accessibility API (XCTest), AT-SPI (Linux). Тесты управляют приложением как пользователь — кликами, вводом, проверкой свойств через accessibility-дерево. Устойчивы к изменениям в реализации, но требуют корректной настройки accessibility.
- На уровне фреймворка: White (WinForms/WPF), TestStack.White, FlaUI (.NET), Jubula (Java), Squish (Qt). Используют внутренние API контролов, что даёт больше возможностей, но делает тесты хрупкими при обновлении фреймворка.
- Для Electron: Spectron (устаревший), Playwright/TestCafe с поддержкой Electron. Управление через DevTools Protocol, доступ к renderer- и main-процессам.
Практики:
- Использование уникальных идентификаторов (AutomationId в WPF, test-id в Electron) вместо текста или порядка элементов.
- Ожидание состояний («ждать, пока кнопка станет кликабельной»), а не фиксированные Thread.Sleep.
- Запуск в изолированной среде (чистый профиль пользователя, отдельный экран в CI).
- Скриншоты при падении для диагностики.

Нагрузочное и стресс-тестирование — актуально для приложений с длительным временем жизни (почтовые клиенты, мессенджеры). Проверяется:

Утечки памяти при открытии/закрытии окон.
Поведение при нехватке памяти/диска.
Стабильность при длительной работе (сутки+).
Инструменты: PerfMon (Windows), valgrind --tool=memcheck (Linux), Visual Studio Diagnostic Tools.

Ручное тестирование остаётся необходимым для:

Проверки визуального соответствия макетам.
Оценки юзабилити (удобство горячих клавиш, логичность навигации).
Тестирования на разных конфигурациях (DPI, разрешения, темы ОС).
Рекомендуется вести матрицу тестирования по версиям ОС, языкам, темам.

DevOps для десктопных приложений

Автоматизация жизненного цикла десктопного ПО — ключ к стабильности и скорости доставки.

CI/CD-конвейер типично включает:

Сборка:
- Кросс-платформенная компиляция (например, в GitHub Actions: windows-latest, macos-latest, ubuntu-latest).
- Создание артефактов: .msi, .dmg, .deb, .AppImage, Flatpak.
Тестирование:
- Запуск unit/integration-тестов.
- UI-тесты в headless-режиме (Xvfb для Linux, Virtual Machines для Windows/macOS).
Подпись кода:
- Использование сертификатов, хранящихся в секретах CI (Azure Key Vault, HashiCorp Vault).
- Автоматическая подпись через signtool (Windows), codesign (macOS), gpg (Linux).
Упаковка:
- MSIX для Microsoft Store.
- jpackage для JavaFX (создаёт native installers).
- electron-builder/tauri-cli для Electron/Tauri.
Публикация:
- Загрузка в GitHub Releases.
- Публикация в Microsoft Partner Center, Apple App Store Connect, Flathub через API.
- Обновление репозиториев (PPA, Homebrew tap).

Управление версиями — требует особого подхода:

Использование семантического версионирования (SemVer: MAJOR.MINOR.PATCH).
Автоматическая генерация номера сборки из CI (например, 1.2.0+build.245).
Внедрение версии в метаданные: AssemblyInfo.cs, Info.plist, package.json.
Хранение changelog в формате, понятном пользователям («Исправлена ошибка сохранения при отключённом интернете»).

Обратная связь от пользователей — критически важна для десктопа:

Встроенные системы отчётов об ошибках (например, Microsoft.AppCenter.Crashes).
Анонимная телеметрия (с явным согласием) для анализа использования функций.
Механизмы «отправить отзыв» в самом приложении.

Примеры кода

1. Асинхронная операция с обновлением UI (C# / WPF, MVVM)

Задача: Загрузить данные из сети при нажатии кнопки, показать прогресс, обновить список — без блокировки интерфейса.

<!-- MainWindow.xaml -->
<Window x:Class="AsyncDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        Title="Асинхронная загрузка" Height="350" Width="500">
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>

        <Button Content="Загрузить данные" 
                Command="{Binding LoadDataCommand}"
                IsEnabled="{Binding IsLoading, Converter={StaticResource InverseBooleanConverter}}"
                Margin="0,0,0,10"/>

        <ProgressBar Grid.Row="1" 
                     IsIndeterminate="True"
                     Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibilityConverter}}"
                     Height="4" Margin="0,5"/>

        <ListBox Grid.Row="1" 
                 ItemsSource="{Binding Items}"
                 Visibility="{Binding IsLoading, Converter={StaticResource InverseBoolToVisibilityConverter}}"
                 Margin="0,10,0,0"/>
    </Grid>
</Window>

// MainWindowViewModel.cs
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows.Input;

namespace AsyncDemo
{
    public class MainWindowViewModel : INotifyPropertyChanged
    {
        private bool _isLoading;
        private ObservableCollection<string> _items = new();

        public bool IsLoading
        {
            get => _isLoading;
            set => SetProperty(ref _isLoading, value);
        }

        public ObservableCollection<string> Items
        {
            get => _items;
            set => SetProperty(ref _items, value);
        }

        public ICommand LoadDataCommand { get; }

        public MainWindowViewModel()
        {
            // RelayCommand — простая реализация ICommand (можно взять из CommunityToolkit.Mvvm)
            LoadDataCommand = new RelayCommand(async () => await LoadDataAsync());
        }

        private async Task LoadDataAsync()
        {
            // Важно: не блокируем UI-поток
            IsLoading = true;

            try
            {
                // Имитация сетевого запроса (в реальности — HttpClient)
                var data = await Task.Run(() =>
                {
                    Thread.Sleep(2000); // Эмуляция задержки
                    return new[] { "Элемент 1", "Элемент 2", "Элемент 3" };
                });

                // Обновление коллекции — безопасно, так как WPF автоматически маршалирует изменения в UI-поток
                // (только если коллекция реализует INotifyCollectionChanged, как ObservableCollection)
                Items.Clear();
                foreach (var item in data)
                    Items.Add(item);
            }
            finally
            {
                IsLoading = false;
            }
        }

        // Реализация INotifyPropertyChanged — стандартная
        public event PropertyChangedEventHandler? PropertyChanged;
        protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
        {
            if (!EqualityComparer<T>.Default.Equals(field, value))
            {
                field = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

Пояснения:

IsLoading управляет видимостью прогресс-бара и состоянием кнопки — единый источник истины.
ObservableCollection вместо List — гарантирует уведомления об изменениях без ручного вызова OnPropertyChanged.
Task.Run — выносит имитацию I/O в пул потоков; для реальных сетевых вызовов лучше использовать HttpClient.GetAsync напрямую (он уже асинхронен).
finally — гарантирует сброс IsLoading, даже при исключении.

2. Работа с локальным хранилищем (Python / PyQt6)

Задача: Сохранять и загружать настройки приложения (например, последний открытый путь) между запусками.

# settings_demo.py
import sys
import os
from pathlib import Path
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget, QFileDialog
from PyQt6.QtCore import QSettings, QStandardPaths

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Настройки с QSettings")

        # Инициализация QSettings:
        # - organization — имя организации (для разделения настроек разных приложений)
        # - application — имя приложения
        # Хранится в реестре (Windows), plist (macOS) или ~/.config (Linux)
        self.settings = QSettings("МояОрганизация", "ДемоНастроек")

        self.central_widget = QWidget()
        self.setCentralWidget(self.central_widget)

        layout = QVBoxLayout()
        self.select_button = QPushButton("Выбрать папку")
        self.select_button.clicked.connect(self.select_folder)
        layout.addWidget(self.select_button)

        self.status_label = QPushButton("Последняя папка: (не выбрана)")
        self.status_label.setEnabled(False)
        layout.addWidget(self.status_label)

        self.central_widget.setLayout(layout)

        # Загрузка сохранённого значения при старте
        last_path = self.settings.value("last_folder", "")
        if last_path and os.path.isdir(last_path):
            self.status_label.setText(f"Последняя папка: {last_path}")

    def select_folder(self):
        # Получаем последний путь из настроек (или домашнюю директорию по умолчанию)
        last_path = self.settings.value("last_folder", 
                                       QStandardPaths.writableLocation(QStandardPaths.HomeLocation))

        folder = QFileDialog.getExistingDirectory(
            self, 
            "Выберите папку", 
            last_path  # Начинаем с последнего сохранённого пути
        )

        if folder:
            # Сохраняем путь в настройки
            self.settings.setValue("last_folder", folder)
            self.status_label.setText(f"Последняя папка: {folder}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

Пояснения:

QSettings — кроссплатформенный API для хранения конфигурации. Не требует ручной работы с файлами.
QStandardPaths — гарантирует использование стандартных путей ОС (без жёстко заданных C:\ или /home).
Сохранение происходит сразу при вызове setValue — нет необходимости в sync() (автоматически фиксируется при выходе).
Безопасность: QSettings использует механизмы ОС для изоляции данных (реестр с ACL, защищённые plist).

3. Безопасное хранение учётных данных (C# / .NET, Windows)

Задача: Сохранить и извлечь пароль пользователя без хранения в открытом виде.

// CredentialManager.cs
using System;
using System.Runtime.InteropServices;
using System.Text;

public static class CredentialManager
{
    // Импорт WinAPI — безопаснее, чем сторонние библиотеки
    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    private static extern bool CredWrite(ref Credential credential, uint flags);

    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    private static extern bool CredRead(string target, CredentialType type, int reservedFlag, out IntPtr credentialPtr);

    [DllImport("advapi32.dll", SetLastError = true)]
    private static extern bool CredFree(IntPtr cred);

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct Credential
    {
        public uint Flags;
        public CredentialType Type;
        public IntPtr TargetName;
        public IntPtr Comment;
        public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
        public uint CredentialBlobSize;
        public IntPtr CredentialBlob;
        public uint Persist;
        public uint AttributeCount;
        public IntPtr Attributes;
        public IntPtr TargetAlias;
        public IntPtr UserName;
    }

    private enum CredentialType : uint
    {
        Generic = 1,
        DomainPassword = 2,
        DomainCertificate = 3,
        DomainVisiblePassword = 4,
        GenericCertificate = 5,
        DomainExtended = 6,
        Maximum = 7,
        MaximumEx = Maximum + 1000
    }

    public static void SaveCredential(string targetName, string userName, string password)
    {
        var cred = new Credential
        {
            Type = CredentialType.Generic,
            TargetName = Marshal.StringToCoTaskMemUni(targetName),
            UserName = Marshal.StringToCoTaskMemUni(userName),
            CredentialBlobSize = (uint)Encoding.Unicode.GetBytes(password).Length,
            CredentialBlob = Marshal.StringToCoTaskMemUni(password),
            Persist = 2 // CRED_PERSIST_LOCAL_MACHINE (сохраняется между перезагрузками)
        };

        try
        {
            if (!CredWrite(ref cred, 0))
                throw new Exception($"Ошибка сохранения учётных данных: {Marshal.GetLastWin32Error()}");
        }
        finally
        {
            Marshal.FreeCoTaskMem(cred.TargetName);
            Marshal.FreeCoTaskMem(cred.UserName);
            Marshal.FreeCoTaskMem(cred.CredentialBlob);
        }
    }

    public static (string? UserName, string? Password) ReadCredential(string targetName)
    {
        if (!CredRead(targetName, CredentialType.Generic, 0, out IntPtr credPtr))
        {
            var error = Marshal.GetLastWin32Error();
            if (error == 1168) // ERROR_NOT_FOUND
                return (null, null);
            throw new Exception($"Ошибка чтения учётных данных: {error}");
        }

        try
        {
            var cred = Marshal.PtrToStructure<Credential>(credPtr);
            var userName = cred.UserName != IntPtr.Zero ? Marshal.PtrToStringUni(cred.UserName) : null;
            var password = cred.CredentialBlob != IntPtr.Zero 
                ? Marshal.PtrToStringUni(cred.CredentialBlob, (int)cred.CredentialBlobSize / 2) 
                : null;
            return (userName, password);
        }
        finally
        {
            CredFree(credPtr);
        }
    }
}

// Пример использования в ViewModel
/*
var (user, pwd) = CredentialManager.ReadCredential("MyApp");
if (user != null)
{
    Username = user;
    // Пароль можно использовать для автоматического входа — но НИКОГДА не сохранять в свойствах ViewModel
}
else
{
    // Требуем ввод логина/пароля
}
*/

Пояснения:

Используется Windows Credential Manager — системное хранилище, защищённое DPAPI.
Пароль никогда не хранится в памяти как строка (только как IntPtr до момента использования).
Обработка ошибок: ERROR_NOT_FOUND (1168) — нормальный случай для первого запуска.
Альтернативы: ProtectedData для шифрования данных в файлах, но Credential Manager предпочтительнее — интеграция с политиками безопасности ОС.

4. Кроссплатформенное окно с WebView (Rust / Tauri)

Задача: Минимальное приложение с веб-интерфейсом и вызовом нативной функции из JS.

src-tauri/tauri.conf.json (фрагмент):

{
  "build": {
    "beforeBuildCommand": "npm run build",
    "beforeDevCommand": "npm run dev",
    "devPath": "http://localhost:1420",
    "distDir": "../dist"
  },
  "tauri": {
    "allowlist": {
      "shell": { "all": false, "open": true },
      "dialog": { "all": false, "open": true, "save": true }
    }
  }
}

src-tauri/src/main.rs:

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

use tauri::Manager;

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Привет, {}! Текущее время: {}", name, chrono::Local::now().format("%H:%M:%S"))
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .setup(|app| {
            // Дополнительная инициализация (например, проверка обновлений)
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("Ошибка запуска приложения");
}

src/App.svelte (или любой фронтенд):

<script>
  import { invoke } from '@tauri-apps/api';

  async function greetUser() {
    try {
      const response = await invoke('greet', { name: 'Тимур' });
      document.getElementById('output').innerText = response;
    } catch (error) {
      console.error('Ошибка вызова команды:', error);
    }
  }
</script>

<button onclick="greetUser()">Поприветствовать</button>
<div id="output"></div>

Пояснения:

#[tauri::command] — макрос для регистрации Rust-функции как вызываемой из JS.
invoke — безопасный IPC-канал (через window.__TAURI__.invoke).
allowlist в конфиге — явное разрешение функций (по умолчанию всё запрещено).
Бинарник получается < 5 МБ (в отличие от Electron).

5. Локализация через ресурсы (Java / JavaFX)

src/main/resources/i18n/messages.properties:

app.title=Приложение
button.greet=Приветствовать
greeting=Здравствуйте, {0}!

src/main/resources/i18n/messages_ru_RU.properties:

app.title=Приложение
button.greet=Поприветствовать
greeting=Здравствуйте, {0}!

src/main/resources/i18n/messages_en_US.properties:

app.title=Application
button.greet=Greet
greeting=Hello, {0}!

MainApp.java:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;

public class MainApp extends Application {
    private ResourceBundle resources;

    @Override
    public void init() {
        // Определяем локаль: сначала из системной, можно переопределить через аргументы
        Locale locale = Locale.getDefault();
        resources = ResourceBundle.getBundle("i18n.messages", locale);
    }

    @Override
    public void start(Stage primaryStage) {
        Button greetButton = new Button(resources.getString("button.greet"));
        Label outputLabel = new Label();

        greetButton.setOnAction(e -> {
            String greeting = resources.getString("greeting");
            String formatted = MessageFormat.format(greeting, "Тимур");
            outputLabel.setText(formatted);
        });

        VBox root = new VBox(10, greetButton, outputLabel);
        Scene scene = new Scene(root, 300, 150);
        primaryStage.setTitle(resources.getString("app.title"));
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

Пояснения:

ResourceBundle автоматически выбирает нужный файл по локали.
MessageFormat — для параметризованных строк (без конкатенации!).
Добавление новой локали — просто создание messages_xx_XX.properties.
Для RTL (арабский, иврит) в JavaFX достаточно установить scene.setNodeOrientation(NodeOrientation.RIGHT_TO_LEFT).

Особенности разработки десктопных приложений​

Многопоточность и реактивность​

Ресурсы​

Отладка и профилирование​

Локализация​

Доступность​

Безопасность​

Обзор популярных решений и фреймворков​

.NET-экосистема (C#, F#)​

Java​

C++/Qt​

JavaScript/TypeScript​

Архитектурные паттерны в десктопной разработке​

MVC​

MVP​

MVVM​

Clean Architecture / Onion Architecture​

Тестирование десктопных приложений​

DevOps для десктопных приложений​

Примеры кода​

1. Асинхронная операция с обновлением UI (C# / WPF, MVVM)​

2. Работа с локальным хранилищем (Python / PyQt6)​

3. Безопасное хранение учётных данных (C# / .NET, Windows)​

4. Кроссплатформенное окно с WebView (Rust / Tauri)​

5. Локализация через ресурсы (Java / JavaFX)​

Особенности разработки десктопных приложений

Многопоточность и реактивность

Ресурсы

Отладка и профилирование

Локализация

Доступность

Безопасность

Обзор популярных решений и фреймворков

.NET-экосистема (C#, F#)

Java

C++/Qt

JavaScript/TypeScript

Архитектурные паттерны в десктопной разработке

MVC

MVP

MVVM

Clean Architecture / Onion Architecture

Тестирование десктопных приложений

DevOps для десктопных приложений

Примеры кода

1. Асинхронная операция с обновлением UI (C# / WPF, MVVM)

2. Работа с локальным хранилищем (Python / PyQt6)

3. Безопасное хранение учётных данных (C# / .NET, Windows)

4. Кроссплатформенное окно с WebView (Rust / Tauri)

5. Локализация через ресурсы (Java / JavaFX)