Благодарности
Введение
Обзор глав
От издательства
Глава 1. Введение в WPF
Аппаратное ускорение и WPF
WPF: высокоуровневый API-интерфейс
Архитектура WPF
WPF4
Поддержка множества целевых платформ
Клиентский профиль .NET
Визуальный конструктор Visual Studio
Резюме
Глава 2. XAML
Компиляция XAML
Основы XAML
Класс отделенного кода
Свойства и события в XAML
Сложные свойства
Расширения разметки
Присоединенные свойства
Вложенные элементы
Специальные символы и пробелы
События
Полный пример автоответчика
Использование типов из других пространств имен
Загрузка и компиляция XAML
Код и не компилированный XAML
Код и скомпилированный XAML
Только XAML
XAML 2009
Встроенные типы
Расширенное создание объектов
Резюме
Глава 3. Компоновка
Контейнеры компоновки
Простая компоновка с помощью StackPanel
Поля
Минимальные, максимальные и явные размеры
Элемент Border
WrapPanelHDockPanel
DockPanel
Вложение контейнеров компоновки
Grid
Округление компоновки
Объединение строк и колонок
Разделенные окна
Группы с общими размерами
Координатная компоновка с помощью Canvas
InkCanvas
Примеры компоновки
Динамическое содержимое
Модульный пользовательский интерфейс
Резюме
Глава 4. Свойства зависимости
Регистрация свойства зависимости
Проверка свойств
Резюме
Глава 5. Маршрутизируемые события
Обработка маршрутизируемого события
Маршрутизация событий
События WPF
События ввода
Ввод с клавиатуры .
Ввод с использованием мыши
Сенсорный многопозиционный ввод
Резюме
Глава 6. Элементы управления
Шрифты
Курсоры мыши
Элементы управления содержимым
Кнопки
Всплывающие подсказки
Специализированные контейнеры
Класс Tabltem
Класс Expander
Текстовые элементы управления
Выделение текста
Проверка правописания
Элементы управления списками
Класс ComboBox
Элементы управления, основанные на диапазонах значений
Класс ProgressBar
Элементы управления датами
Резюме
Глава 7. Класс Application
Наследование специального класса приложения
Останов приложения
События класса Application
Задачи приложения
Обработка аргументов командной строки
Доступ к текущему приложению
Взаимодействие между окнами
Приложение одного экземпляра
Ресурсы сборки
Извлечение ресурсов
Ресурсы в других сборках
Файлы содержимого
Локализация
Подготовка приложения для локализации
Процесс перевода
Резюме
Глава 8. Привязка элементов
Ошибки привязки
Режимы привязки
Создание привязки в коде
Множественные привязки
Обновления привязок
Привязка к объектам, не являющимся элементами
Свойство RelativeSource
Свойство DataContext
Резюме
Глава 9. Команды
Модель команд WPF
КлассRoutedCommand
Класс RoutedUICommand
Библиотека команд
Выполнение команд
Привязки команд
Использование множества источников команд
Точная настройка текста команды
Вызов команды напрямую
Отключение команд
Элементы управления со встроенными командами
Расширенные команды
Использование одной и той же команды в разных местах
Использование параметра команды
Отслеживание и отмена команд
Резюме
Глава 10. Ресурсы
Иерархия ресурсов
Статические и динамические ресурсы
Неразделяемые ресурсы
Ресурсы приложения
Ресурсы системы
Словари ресурсов
Использование словаря ресурсов
Разделение ресурсов между сборками
Резюме
Глава 11. Стили и поведения
Установка свойств
Присоединение обработчиков событий
Множество уровней стилей
Автоматическое применение стилей по типу
Триггеры
Триггер события
Поведения
Модель поведений
Создание поведения
Использование поведения
Поддержка использования поведений во время проектирования в Expression Blend
Резюме
Глава 12. Фигуры, кисти и трансформации
Rectangle и Ellipse
Установка размеров и расположения фигур
Масштабирование фигур в Viewbox
Line
Polyline
Polygon
Наконечники и стыки линий
Пунктирные линии
Привязка к пикселям
Кисти
LinearGradientBrush
RadialGradientBrush
ImageBrush
Мозаичная кисть ImageBrush
VisualBrush
BitmapCacheBrush
Трансформации
Трансформация элементов
Прозрачность
Маски непрозрачности
Резюме
Глава 13. Классы Geometry и Drawing
Комбинирование фигур в GeometryGroup
Комбинирование объектов Geometry и CombinedGeometry
Кривые и прямые линии, представляемые с помощью PathGeometry
Мини-язык описания геометрии
Кадрирование геометрии
Рисунки
Экспорт рисунка
Резюме
Глава 14. Эффекты и класс Visual
Помещение визуальных объектов в оболочку элемента
Проверка попадания
Сложная проверка попадания
Эффекты
КлассDropShadowEffeet
Класс ShaderEffeet
Класс WriteableBitmap
Запись в WriteableBitmap
Более эффективная запись пикселей
Резюме
Глава 15. Основы анимации
Анимация на основе свойств
Базовая анимация
Анимация в коде
Время жизни анимации
Класс TimeLine
Раскадровки
Триггеры событий
Перекрывающиеся анимации
Синхронизированные анимации
Управление воспроизведением
Отслеживание хода анимации
Плавность анимации
Режимы плавности
Классы функций плавности
Создание специальной функции плавности
Производительность анимации
Кэширование растровых изображений
Резюме
Глава 16. Расширенная анимация
Анимированные кисти
Анимация построителей текстур
Анимация ключевого кадра
Дискретные анимации ключевого кадра
Плавные ключевые кадры
Сплайновые анимации ключевого кадра
Анимация на основе пути
Анимация на основе кадра
Раскадровки в коде
Пользовательский элемент управления Bomb
Сброс бомб
Перехват бомбы
Подсчет бомб и очистка
Резюме
Глава 17. Шаблоны элементов управления
Что собой представляют шаблоны
Анализ элементов управления
Создание шаблонов элементов управления
Привязки шаблона
Триггеры, изменяющие свойства
Триггеры, использующие анимацию
Организация ресурсов для шаблонов
Применение шаблонов со стилями
Автоматическое применение шаблонов
Обложки, выбранные пользователем
Построение более сложных шаблонов
Модификация полосы прокрутки
Примеры шаблонов элементов управления
Визуальные состояния
Резюме
Глава 18. Пользовательские элементы
Построение базового пользовательского элемента управления
Определение маршрутизируемых событий
Добавление кода разметки
Поддержка команд
Пристальный взгляд на UserControl
Создание элемента управления, лишенного внешнего вида
Рефакторинг кода разметки указателя цвета
Оптимизация шаблона элемента управления
Стили, специфичные для темы, и стиль по умолчанию
Поддержка визуальных состояний
Выбор частей и состояний
Шаблон элемента управления, принятый по умолчанию
Использование другого шаблона элемента управления
Пользовательские панели
Клон Canvas
Улучшенная панель WrapPanel
Рисованные элементы
Выполнение специального рисования
Элемент, выполняющий специальное рисование
Специальный декоратор
Резюме
Глава 19. Привязка данных
Отображение привязанного объекта
Уведомление об изменениях
Привязка к коллекции объектов
Вставка и удаление элементов коллекций
Привязка объектов ADO.NET
Привязка к выражению LINQ
Повышение производительности больших списков
Повторное использование контейнера элементов
Проверка достоверности
Класс ExceptionValidationRule
КлассDataErrorValidationRule
Специальные правила проверки достоверности
Получение списка ошибок
Отображение отличающегося индикатора ошибки
Проверка достоверности множества значений
Поставщики данных
Поставщик XmlDataProvider
Резюме
Глава 20. Форматирование привязанных данных
Преобразование данных
Форматирование строк с помощью конвертера значений
Создание объектов с конвертером значений
Применение условного форматирования
Оценка множества свойств
Списочные элементы управления
Стили списков
Элемент ListBox c флажками или переключателями
Стиль чередующихся элементов
Селекторы стиля
Шаблоны данных
Более развитые шаблоны
Варьирование шаблонов
Селекторы шаблонов
Шаблоны и выбор
Изменение компоновки элемента
Элемент ComboBox
Резюме
Глава 21. Представления данных
Навигация в представлении
Создание представления декларативным образом
Фильтрация, сортировка и группирование
Фильтрация объекта DataTable
Сортировка
Группирование
Резюме
Глава 22. Элементы управления ListView, TreeView и DataGrid
Изменение размера столбцов
Шаблоны ячеек
Создание специального представления
Элемент управления TreeView
Привязка элемента управления TreeView к объекту DataSet
Оперативное создание узлов
Элемент управления DataGrid
Определение столбцов
Форматирование и стилизация столбцов
Форматирование строк
Детали строк
Закрепление столбцов
Редактирование BDataGrid
Резюме
Глава 23. Окна
Позиционирование окна
Сохранение и восстановление информации о местоположении окна
Взаимодействие окон
Модель диалогового окна
Общие диалоговые окна
Непрямоугольные окна
Прозрачные окна с содержимым необычной формы
Перемещение окон нестандартной формы
Изменение размеров окон нестандартной формы
Шаблон элемента управления для окон
Эффект Aero Glass
Программирование для панели задач Windows 7
Изменение значков и окон предварительного просмотра, отображаемых в панели задач
Резюме
Глава 24. Страницы и навигация
Страничные интерфейсы
Класс Page
Гиперссылки
Размещение страниц во фрейме
Размещение страниц внутри другой страницы
Размещение страниц в веб-браузере
Хронология страниц
Хронология навигации
Добавление специальных свойств
Служба навигации
События навигации
Управление журналом
Добавление в журнал специальных элементов
Страничные функции
Приложения ХВАР
Создание приложения ХВАР
Развертывание приложения ХВАР
Обновление приложения ХВАР
Безопасность приложения ХВАР
Приложения ХВАР с полным доверием
Кодирование с обеспечением различных уровней безопасности
Эмуляция диалоговых окон с помощью элемента управления Popup
Вставка ХВАР-приложения в веб-страницу
Элемент управления WebBrowser
Построение дерева DOM
Написание сценариев для веб-страницы с помощью кода .NET
Резюме
Глава 25. Меню, панели инструментов и ленты
Элементы меню
Класс ContextMenu
Разделители меню
Панели инструментов и строки состояния
Элемент управления StatusBar
Ленты
Стилизация элемента управления Ribbon
Команды
Меню приложения
Вкладки, группы и кнопки
Изменение размеров элемента управления Ribbon
Панель быстрого запуска
Резюме
Глава 26. Звук и видео
Класс SoundPlayerAction
Класс MediaPlayer
Элемент MediaElement
Обработка событий
Воспроизведение аудио с помощью триггеров
Воспроизведение множества звуков
Изменение громкости, баланса, скорости и позиции воспроизведения
Синхронизация анимации с аудио
Воспроизведение видео
Видео-эффекты
Речь
Распознавание текста
Резюме
Глава 27. Трехмерная графика
Трехмерные объекты
Камера
Дополнительные сведения о трехмерной графике
Более сложные фигуры
Коллекции Model3DGroup
Снова о материалах
Отображение текстур
Интерактивность и анимация
Полеты
Шаровой манипулятор
Проверка попадания
Двухмерные элементы на трехмерных поверхностях
Резюме
Глава 28. Документы
Потоковые документы
Форматирование элементов вывода содержимого
Создание простого потокового документа
Блочные элементы
Строковые элементы
Программное взаимодействие с элементами
Выравнивание текста
Контейнеры потоковых документов, доступные только для чтения
Страницы и колонки
Печать
Редактирование потокового документа
Сохранение файла
Форматирование выделенного текста
Получение отдельных слов
Фиксированные документы
Аннотации
Включение службы аннотаций
Создание аннотаций
Просмотр аннотаций
Хранение аннотаций в фиксированном документе
Настройка внешнего вида наклеек
Резюме
Глава 29. Печать
Трансформация печатного вывода
Печать элементов без их отображения
Печать документа
Манипуляции страницами в печатном выводе документа
Специальная печать
Специальная печать с разбиением на страницы
Настройки и управление печатью
Управление очередью печати
Печать через XPS
Печать непосредственно на принтер через XPS
Асинхронная печать
Резюме
Глава 30. Взаимодействие с Windows Forms
Смешивание окон и форм
Отображение модальных окон и форм
Визуальные стили элементов управления Windows Forms
Классы Windows Forms, которые не нуждаются во взаимодействии
Создание окон со смешанным содержимым
Размещение элементов управления Windows Forms в WPF
WPF и пользовательские элементы управления Windows Forms
Размещение элементов управления WPF в форме Windows Forms
Клавиши доступа, мнемоники и фокус
Отображение свойств
Резюме
Глава 31. Многопоточность
Класс DispatcherObject
Класс BackgroundWorker
Резюме
Глава 32. Модель дополнений
Конвейер дополнения
Структура каталогов дополнений
Подготовка решения, использующего модель дополнений
Приложение, использующее дополнения
Дополнение
Адаптер дополнения
Адаптер хоста
Хост
Взаимодействие с хостом
Визуальные дополнения
Резюме
Глава 33. Развертывание ClickOnce
Ограничения ClickOnce
Простая публикация ClickOnce
Запуск мастера публикации
Развернутая файловая структура
Установка приложения ClickOnce
Обновление приложения ClickOnce
Дополнительные параметры ClickOnce
Обновления
Ассоциации файлов
Параметры публикации
Резюме
Предметный указатель
Текст
                    Pro
WPF
in C# 2010:
Windows Presentation
Foundation in .NET 4
Matthew MacDonald
Apress®


WPF Windows Presentation Foundation в .NET 4 с примерами на С# 2010 ДЛЯ ПРОФЕССИОНАЛОВ Мэтью Мак-Дональд Москва • Санкт-Петербург • Киев 2011
ББК 32.973.26-018.2.75 М15 УДК 681.3.07 Издательский дом "Вильяме" Зав. редакцией СИ. Тригуб Перевод с английского Я.П. Волковой, А.А. Моргунова, Н.А. Мухина Под редакцией Ю.Н. Артпеменко По общим вопросам обращайтесь в Издательский дом "Вильяме" по адресу: info@williamspublishing.com, http://www.williamspublishing.com Мак-Дональд, Мэтью. М15 WPF 4: Windows Presentation Foundation в .NET 4.0 с примерами на С# 2010 для профессионалов. : Пер. с англ. — М. : ООО "И.Д. Вильяме", 2011. — 1024 с. : ил. — Парал. тит. англ. ISBN 978-5-8459-1657-0 (рус.) ББК 32.973.26-018.2.75 Все названия программных продуктов являются зарегистрированными торговыми марками соответствующих фирм. Никакая часть настоящего издания ни в каких целях не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами, будь то электронные или механические, включая фотокопирование и запись на магнитный носитель, если на это нет письменного разрешения издательства APress, Berkeley, CA. Authorized translation from the English language edition published by APress, Inc., Copyright © 2010 by Matthew MacDonald. All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. Russian language edition is published by Williams Publishing House according to the Agreement with R&I Enterprises International, Copyright © 2011. Научно-популярное издание Мэтью Мак-Дональд WPF 4: Windows Presentation Foundation в .NET 4.0 с примерами на С# 2010 для профессионалов Верстка Т.Н. Артпеменко Художественный редактор ВТ. Павлютпин Подписано в печать 12.01.2011. Формат 70x100/16. Гарнитура Times. Печать офсетная. Усл. печ. л. 82,56. Уч.-изд. л. 71,4. Тираж 1500 экз. Заказ № 25054. Отпечатано по технологии CtP в ОАО "Печатный двор" им. А. М. ГЪрького 197110, Санкт-Петербург, Чкаловский пр., 15. ООО "И. Д. Вильяме", 127055, г. Москва, ул. Лесная, д. 43, стр. 1 ISBN 978-5-8459-1657-0 (рус.) © Издательский дом "Вильяме", 2011 ISBN 978-1-43-027205-2 (англ.) © by Matthew MacDonald, 2010
Оглавление Введение 20 Глава 1. Введение в WPF 25 Глава 2. XAML 46 Глава 3. Компоновка 81 Глава 4. Свойства зависимости 120 Глава 5. Маршрутизируемые события 133 Глава 6. Элементы управления 168 Глава 7. Класс Application 217 Глава 8. Привязка элементов 248 Глава 9. Команды 262 Глава 10. Ресурсы 288 Глава 11. Стили и поведения 302 Глава 12. Фигуры, кисти и трансформации 324 Глава 13. Классы Geometry и Drawing 361 Глава 14. Эффекты и класс Visual 381 Глава 15. Основы анимации 402 Глава 16. Расширенная анимация 441 Глава 17. Шаблоны элементов управления 469 Глава 18. Пользовательские элементы 508 Глава 19. Привязка данных 559 Глава 20. Форматирование привязанных данных 600 Глава 21. Представления данных 641 Глава 22. Элементы управления ListView, TreeView и DataGrid 657 Глава 23. Окна 696 Глава 24. Страницы и навигация 734 Глава 25. Меню, панели инструментов и ленты 780 Глава 26. Звук и видео 805 Глава 27. Трехмерная графика 827 Глава 28. Документы 866 Глава 29. Печать 914 Глава 30. Взаимодействие с Windows Forms 942 Глава 31. Многопоточность 964 Глава 32. Модель дополнений 976 Глава 33. Развертывание ClickOnce 998 Предметный указатель 1016
Содержание Об авторе 19 О техническом рецензенте 19 Благодарности 19 Введение 20 Об этой книге 21 Обзор глав 21 Что необходимо для чтения этой книги 24 Исходный код примеров 24 От издательства 24 Глава 1. Введение в WPF 25 Эволюция графики в Windows 25 DirectX: новый графический механизм 26 Аппаратное ускорение и WPF 26 WPF: высокоуровневый API-интерфейс 28 Независимость от разрешения 31 Архитектура WPF 36 Иерархия классов 37 WPF4 40 Новые средства 41 WPF Toolkit 42 Visual Studio 2010 42 Поддержка множества целевых платформ 42 Клиентский профиль .NET 43 Визуальный конструктор Visual Studio 44 Резюме 45 Глава 2. XAML 46 Особенности XAML 47 Графический интерфейс пользователя до WPF 47 Разновидности XAML 48 Компиляция XAML 48 Основы XAML 50 Пространства имен XAML 51 Класс отделенного кода 52 Свойства и события в XAML 55 Простые свойства и конвертеры типов 56 Сложные свойства 57 Расширения разметки 59 Присоединенные свойства 60 Вложенные элементы 61 Специальные символы и пробелы 64 События 65 Полный пример автоответчика 66 Использование типов из других пространств имен 67 Загрузка и компиляция XAML 69 Только код 70 Код и не компилированный XAML 72 Код и скомпилированный XAML 74 Только XAML 75 XAML 2009 76 Автоматическая привязка событий 77 Ссылки 78 Встроенные типы 78
Содержание 7 Расширенное создание объектов 79 Резюме 80 Глава 3. Компоновка 81 Понятие компоновки в WPF 81 Философия компоновки WPF 82 Процесс компоновки 83 Контейнеры компоновки 83 Простая компоновка с помощью StackPanel 85 Свойства компоновки 87 Выравнивание 88 Поля 88 Минимальные, максимальные и явные размеры 90 Элемент Border 92 WrapPanelHDockPanel 93 WrapPanel 93 DockPanel 94 Вложение контейнеров компоновки 96 Grid 98 Тонкая настройка строк и колонок 100 Округление компоновки 102 Объединение строк и колонок 103 Разделенные окна 104 Группы с общими размерами 107 UniformGnd 110 Координатная компоновка с помощью Canvas 110 Z-порядок 111 InkCanvas 112 Примеры компоновки 114 Колонка настроек 114 Динамическое содержимое 116 Модульный пользовательский интерфейс 117 Резюме 118 Глава 4. Свойства зависимости 120 Свойства зависимости 120 Определение свойства зависимости 121 Регистрация свойства зависимости 121 Проверка свойств 128 Резюме 132 Глава 5. Маршрутизируемые события 133 Знакомство с маршрутизируемыми событиями 133 Определение, регистрация и упаковка маршрутизируемых событий 134 Совместное использование маршрутизируемых событий 135 Генерация маршрутизируемого события 135 Обработка маршрутизируемого события 135 Маршрутизация событий 137 События WPF 145 События времени существования 145 События ввода 147 Ввод с клавиатуры . 149 Ввод с использованием мыши 154 Сенсорный многопозиционный ввод 159 Резюме 167
8 Содержание Глава 6. Элементы управления 168 Класс Control 169 Кисти фона и переднего плана 169 Шрифты 171 Курсоры мыши 176 Элементы управления содержимым 178 Выравнивание содержимого 181 Метки 183 Кнопки 183 Всплывающие подсказки 187 Специализированные контейнеры 194 КлассScrollViewer 194 Элементы управления содержимым с заголовками 197 Класс GroupBox 197 Класс Tabltem 197 Класс Expander 199 Текстовые элементы управления 202 Многострочный текст 202 Выделение текста 203 Проверка правописания 204 Класс PasswordBox 206 Элементы управления списками 206 КлассListBox 207 Класс ComboBox 210 Элементы управления, основанные на диапазонах значений 211 Класс Slider 211 Класс ProgressBar 212 Элементы управления датами 213 Резюме 216 Глава 7. Класс Application 217 Жизненный цикл приложения 217 Создание объекта Application 217 Наследование специального класса приложения 218 Останов приложения 220 События класса Application 221 Задачи приложения 223 Отображение экрана заставки 223 Обработка аргументов командной строки 224 Доступ к текущему приложению 225 Взаимодействие между окнами 226 Приложение одного экземпляра 227 Ресурсы сборки 233 Добавление ресурсов 234 Извлечение ресурсов 235 Упакованные URI 237 Ресурсы в других сборках 237 Файлы содержимого 238 Локализация 239 Создание локализуемых пользовательских интерфейсов 239 Подготовка приложения для локализации 240 Процесс перевода 241 Резюме 247
Содержание 9 Глава 8. Привязка элементов 248 Связывание элементов вместе 248 Выражение привязки 249 Ошибки привязки 249 Режимы привязки 250 Привязка OneWayToSource 252 Привязка Defaut 252 Создание привязки в коде 252 Множественные привязки 253 Обновления привязок 256 Привязка к объектам, не являющимся элементами 258 Свойство Source 258 Свойство RelativeSource 259 Свойство DataContext 260 Резюме 261 Глава 9. Команды 262 Общие сведения о командах 262 Модель команд WPF 264 Интерфейс ICommand 264 КлассRoutedCommand 265 Класс RoutedUICommand 266 Библиотека команд 267 Выполнение команд 268 Источники команд 268 Привязки команд 269 Использование множества источников команд 271 Точная настройка текста команды 272 Вызов команды напрямую 273 Отключение команд 274 Элементы управления со встроенными командами 276 Расширенные команды 278 Специальные команды 278 Использование одной и той же команды в разных местах 280 Использование параметра команды 281 Отслеживание и отмена команд 282 Резюме 287 Глава 10. Ресурсы 288 Общие сведения о ресурсах 288 Коллекция ресурсов 289 Иерархия ресурсов 290 Статические и динамические ресурсы 291 Неразделяемые ресурсы 293 Доступ к ресурсам в коде 294 Ресурсы приложения 294 Ресурсы системы 295 Словари ресурсов 296 Создание словаря ресурсов 296 Использование словаря ресурсов 297 Разделение ресурсов между сборками 298 Резюме 301 Глава 11. Стили и поведения 302 Основные сведения о стилях 302
10 Содержание Создание объекта стиля 306 Установка свойств 307 Присоединение обработчиков событий 308 Множество уровней стилей 310 Автоматическое применение стилей по типу 311 Триггеры 313 Простой триггер 313 Триггер события 315 Поведения 317 Получение поддержки для поведений 317 Модель поведений 318 Создание поведения 319 Использование поведения 321 Поддержка использования поведений во время проектирования в Expression Blend 322 Резюме 323 Глава 12. Фигуры, кисти и трансформации 324 Понятие фигур 324 Классы фигур 325 Rectangle и Ellipse 327 Установка размеров и расположения фигур 328 Масштабирование фигур в Viewbox 330 Line 333 Polyline 334 Polygon 335 Наконечники и стыки линий 336 Пунктирные линии 337 Привязка к пикселям 339 Кисти 340 SolidColorBrush 341 LinearGradientBrush 341 RadialGradientBrush 344 ImageBrush 345 Мозаичная кисть ImageBrush 347 VisualBrush 350 BitmapCacheBrush 351 Трансформации 352 Трансформация фигур 354 Трансформация элементов 355 Прозрачность 356 Как сделать элемент частично прозрачным 356 Маски непрозрачности 358 Резюме 360 Глава 13. Классы Geometry и Drawing 361 Классы Path и Geometry 361 Геометрии линий, прямоугольников и эллипсов 362 Комбинирование фигур в GeometryGroup 363 Комбинирование объектов Geometry и CombinedGeometry 365 Кривые и прямые линии, представляемые с помощью PathGeometry 367 Мини-язык описания геометрии 372 Кадрирование геометрии 374 Рисунки 375 Отображение рисунка 376
Содержание 11 Экспорт рисунка 379 Резюме 380 Глава 14. Эффекты и класс Visual 381 Классы Visual 381 Рисование объектов Visual 382 Помещение визуальных объектов в оболочку элемента 384 Проверка попадания 387 Сложная проверка попадания 389 Эффекты 392 BlurEffect 393 КлассDropShadowEffeet 393 Класс ShaderEffeet 395 КлассWriteableBitmap 396 Генерация растрового изображения 397 Запись в WriteableBitmap 398 Более эффективная запись пикселей 399 Резюме 401 Глава 15. Основы анимации 402 Что собой представляет анимация WPF 403 Анимация на основе таймера 403 Анимация на основе свойств 404 Базовая анимация 405 Классы анимации 405 Анимация в коде 408 Одновременные анимации 413 Время жизни анимации 413 Класс TimeLine 414 Раскадровки 417 Раскадровка 418 Триггеры событий 418 Перекрывающиеся анимации 421 Синхронизированные анимации 422 Управление воспроизведением 423 Отслеживание хода анимации 427 Плавность анимации 428 Использование функции плавности 429 Режимы плавности 430 Классы функций плавности 431 Создание специальной функции плавности 434 Производительность анимации 436 Желательная частота кадров 436 Кэширование растровых изображений 438 Резюме 440 Глава 16. Расширенная анимация 441 Еще раз о типах анимаций 441 Анимированные трансформации 442 Анимированные кисти 446 Анимация построителей текстур 449 Анимация ключевого кадра 450 Дискретные анимации ключевого кадра 451 Плавные ключевые кадры 452 Сплайновые анимации ключевого кадра 453
12 Содержание Анимация на основе пути 454 Анимация на основе кадра 456 Раскадровки в коде 459 DiaBHoe окно 460 Пользовательский элемент управления Bomb 461 Сброс бомб 463 Перехват бомбы 465 Подсчет бомб и очистка 466 Резюме 468 Глава 17. Шаблоны элементов управления 469 Логические и визуальные деревья 470 Что собой представляют шаблоны 474 Классы Chrome 477 Анализ элементов управления 478 Создание шаблонов элементов управления 481 Простая кнопка 481 Привязки шаблона 483 Триггеры, изменяющие свойства 484 Триггеры, использующие анимацию 487 Организация ресурсов для шаблонов 489 Рефакторинг шаблона элемента управления для кнопки 490 Применение шаблонов со стилями 491 Автоматическое применение шаблонов 494 Обложки, выбранные пользователем 495 Построение более сложных шаблонов 497 Вложенные шаблоны 497 Модификация полосы прокрутки 500 Примеры шаблонов элементов управления 504 Визуальные состояния 505 Резюме 507 Глава 18. Пользовательские элементы 508 Что собой представляют пользовательские элементы в WPF 509 Построение базового пользовательского элемента управления 512 Определение свойств зависимости 513 Определение маршрутизируемых событий 516 Добавление кода разметки 517 Использование элемента управления 519 Поддержка команд 519 Пристальный взгляд на UserControl 521 Создание элемента управления, лишенного внешнего вида 523 Рефакторинг кода указателя цвета 523 Рефакторинг кода разметки указателя цвета 524 Оптимизация шаблона элемента управления 526 Стили, специфичные для темы, и стиль по умолчанию 529 Поддержка визуальных состояний 531 Начало проектирования класса Flip Panel 532 Выбор частей и состояний 534 Шаблон элемента управления, принятый по умолчанию 535 Использование FlipPanel 542 Использование другого шаблона элемента управления 542 Пользовательские панели 544 Двухшаговый процесс компоновки 545 Клон Canvas 547
Содержание 13 Улучшенная панель WrapPanel 548 Рисованные элементы 551 Метод OnRender () 552 Выполнение специального рисования 553 Элемент, выполняющий специальное рисование 554 Специальный декоратор 556 Резюме 558 Глава 19. Привязка данных 559 Привязка пользовательских объектов к базе данных 559 Построение компонента доступа к данным 560 Построение объекта данных 563 Отображение привязанного объекта 563 Обновление базы данных 566 Уведомление об изменениях 566 Привязка к коллекции объектов 568 Отображение и редактирование элементов коллекции 569 Вставка и удаление элементов коллекций 572 Привязка объектов ADO.NET 573 Привязка к выражению LINQ 574 Повышение производительности больших списков 576 Виртуализация 577 Повторное использование контейнера элементов 578 Отложенная прокрутка 579 Проверка достоверности 579 Проверка достоверности в объекте данных 580 Класс ExceptionValidationRule 581 КлассDataErrorValidationRule 582 Специальные правила проверки достоверности 583 Реакция на ошибки проверки достоверности 586 Получение списка ошибок 586 Отображение отличающегося индикатора ошибки 587 Проверка достоверности множества значений 590 Поставщики данных 593 Поставщик ObjectDataProvider 594 Поставщик XmlDataProvider 597 Резюме 598 Глава 20. Форматирование привязанных данных 600 Еще раз о привязке данных 600 Преобразование данных 602 Свойство StringFormat 602 Что собой представляют конвертеры значений 604 Форматирование строк с помощью конвертера значений 604 Создание объектов с конвертером значений 606 Применение условного форматирования 608 Оценка множества свойств 610 Списочные элементы управления 611 Стили списков 614 СтильItemContainerStyle 614 Элемент ListBoxc флажками или переключателями 616 Стиль чередующихся элементов 618 Селекторы стиля 619 Шаблоны данных 622 Отделение и повторное использование шаблонов 624
14 Содержание Более развитые шаблоны 625 Варьирование шаблонов 628 Селекторы шаблонов 629 Шаблоны и выбор 632 Изменение компоновки элемента 636 Элемент ComboBox 638 Резюме 640 Глава 21. Представления данных 641 Объект представления 641 Извлечение объекта представления 642 Навигация в представлении 642 Создание представления декларативным образом 645 Фильтрация, сортировка и группирование 647 Фильтрация коллекций 647 Фильтрация объекта DataTable 650 Сортировка 651 Группирование 652 Резюме 656 Глава 22. Элементы управления ListView, TreeView и DataGrid 657 Элемент управления L i s tVi e w 658 Создание столбцов с помощью Grid View 659 Изменение размера столбцов 660 Шаблоны ячеек 661 Создание специального представления 663 Элемент управления TreeView 671 Привязка данных к элементу управления Т г е еVi e w 672 Привязка элемента управления TreeView к объекту DataSet 674 Оперативное создание узлов 675 Элемент управления DataGrid 678 Изменение размера и порядка следования столбцов 680 Определение столбцов 682 Форматирование и стилизация столбцов 686 Форматирование строк 688 Детали строк 690 Закрепление столбцов 691 Выбор 692 Сортировка 692 Редактирование BDataGrid 692 Резюме 695 Глава 23. Окна 696 Класс Window 696 Отображение окна 699 Позиционирование окна 700 Сохранение и восстановление информации о местоположении окна 701 Взаимодействие окон 703 Владение окнами 705 Модель диалогового окна 705 Общие диалоговые окна 706 Непрямоугольные окна 708 Простое окно нестандартной формы 708 Прозрачные окна с содержимым необычной формы 711 Перемещение окон нестандартной формы 712
Содержание 15 Изменение размеров окон нестандартной формы 713 Шаблон элемента управления для окон 714 Эффект Aero Glass 718 Программирование для панели задач Windows 7 722 Применение списков часто используемых элементов 723 Изменение значков и окон предварительного просмотра, отображаемых в панели задач 728 Резюме 733 Глава 24. Страницы и навигация 734 Общие сведения о страничной навигации 735 Страничные интерфейсы 735 Простое страничное приложение с элементом NavigationWindow 736 Класс Page 737 Гиперссылки 738 Размещение страниц во фрейме 741 Размещение страниц внутри другой страницы 742 Размещение страниц в веб-браузере 743 Хронология страниц 744 Более детальное рассмотрение URI-адресов в WPF 744 Хронология навигации 745 Добавление специальных свойств 747 Служба навигации 748 Программная навигация 748 События навигации 749 Управление журналом 751 Добавление в журнал специальных элементов 753 Страничные функции 757 Приложения ХВАР 760 Требования для приложений ХВАР 761 Создание приложения ХВАР 761 Развертывание приложения ХВАР 762 Обновление приложения ХВАР 764 Безопасность приложения ХВАР 765 Приложения ХВАР с полным доверием 766 Комбинирование приложений ХВАР и автономных приложений 767 Кодирование с обеспечением различных уровней безопасности 767 Эмуляция диалоговых окон с помощью элемента управления Popup 770 Вставка ХВАР-приложения в веб-страницу 772 Элемент управления WebBrowser 773 Навигация к странице 774 Построение дерева DOM 775 Написание сценариев для веб-страницы с помощью кода .NET 777 Резюме 779 Глава 25. Меню, панели инструментов и ленты 780 Меню 780 Класс Menu 781 Элементы меню 782 Класс ContextMenu 784 Разделители меню 785 Панели инструментов и строки состояния 786 Элемент управления Tool Bar 786 Элемент управления StatusBar 790
16 Содержание Ленты 791 Добавление элемента управления Ribbon 792 Стилизация элемента управления Ribbon 793 Команды 794 Меню приложения 795 Вкладки, группы и кнопки 798 Изменение размеров элемента управления Ribbon 800 Панель быстрого запуска 802 Резюме 804 Глава 26. Звук и видео 805 Воспроизведение WAV-аудио 805 Класс SoundPlayer 806 Класс SoundPlayerAction 807 Системные звуки 808 Класс MediaPlayer 808 Элемент MediaElement 810 Программное воспроизведение аудио 810 Обработка событий 811 Воспроизведение аудио с помощью триггеров 812 Воспроизведение множества звуков 814 Изменение громкости, баланса, скорости и позиции воспроизведения 815 Синхронизация анимации с аудио 817 Воспроизведение видео 818 Видео-эффекты 819 Речь 822 Синтез речи 822 Распознавание текста 824 Резюме 826 Глава 27. Трехмерная графика 827 Основы трехмерной графики 828 Окно просмотра 828 Трехмерные объекты 829 Камера 836 Дополнительные сведения о трехмерной графике 840 Текстурирование и нормали 841 Более сложные фигуры 844 Коллекции Model3DGroup 845 Снова о материалах 847 Отображение текстур 849 Интерактивность и анимация 852 Трансформации 853 Вращения 854 Полеты 854 Шаровой манипулятор 857 Проверка попадания 858 Двухмерные элементы на трехмерных поверхностях 862 Резюме 865 Глава 28. Документы 866 Документы 866 Потоковые документы 867 Потоковые элементы 868 Форматирование элементов вывода содержимого 870
Содержание 17 Создание простого потокового документа 871 Блочные элементы 873 Строковые элементы 878 Программное взаимодействие с элементами 884 Выравнивание текста 887 Контейнеры потоковых документов, доступные только для чтения 888 Изменение масштаба 889 Страницы и колонки 890 Загрузка документов из файла 893 Печать 893 Редактирование потокового документа 894 Загрузка файла 894 Сохранение файла 896 Форматирование выделенного текста 897 Получение отдельных слов 899 Фиксированные документы 901 Аннотации 902 Классы аннотаций 902 Включение службы аннотаций 903 Создание аннотаций 905 Просмотр аннотаций 908 Реагирование на изменения аннотаций 911 Хранение аннотаций в фиксированном документе 911 Настройка внешнего вида наклеек 912 Резюме 913 Глава 29. Печать 914 Базовая печать 914 Печать элемента 915 Трансформация печатного вывода 917 Печать элементов без их отображения 919 Печать документа 920 Манипуляции страницами в печатном выводе документа 923 Специальная печать 925 Печать с помощью классов визуального уровня 926 Специальная печать с разбиением на страницы 928 Настройки и управление печатью 933 Поддержка настроек печати 933 Печать диапазонов страниц 934 Управление очередью печати 934 Печать через XPS 937 Создание документа XPS для предварительного просмотра перед печатью 938 Запись в документ XPS, находящийся в памяти 939 Печать непосредственно на принтер через XPS 939 Асинхронная печать 940 Резюме 941 Глава 30. Взаимодействие с Windows Forms 942 Оценка способности к взаимодействию 942 Средства, которые отсутствуют в WPF 943 Смешивание окон и форм 945 Добавление форм к приложению WPF 945 Добавление окон WPF в приложение Windows Forms 946 Отображение модальных окон и форм 946
18 Содержание Отображение немодальных окон и форм 947 Визуальные стили элементов управления Windows Forms 947 Классы Windows Forms, которые не нуждаются во взаимодействии 948 Создание окон со смешанным содержимым 952 Зазор между WPF и Windows Forms 952 Размещение элементов управления Windows Forms в WPF 954 WPF и пользовательские элементы управления Windows Forms 956 Размещение элементов управления WPF в форме Windows Forms 957 Клавиши доступа, мнемоники и фокус 959 Отображение свойств 961 Резюме 963 Глава 31. Многопоточность 964 Многопоточность 964 Диспетчер 965 Класс DispatcherObject 966 Класс BackgroundWorker 968 Резюме 975 Глава 32. Модель дополнений 976 Выбор между MAF и MEF 976 Конвейер дополнения 977 Как работает конвейер 978 Структура каталогов дополнений 980 Подготовка решения, использующего модель дополнений 981 Приложение, использующее дополнения 982 Контракт 983 Представление дополнения 984 Дополнение 984 Адаптер дополнения 985 Представление хоста 986 Адаптер хоста 986 Хост 987 Добавление новых дополнений 990 Взаимодействие с хостом 990 Визуальные дополнения 995 Резюме 997 Глава 33. Развертывание ClickOnce 998 Что собой представляет развертывание приложения 999 Модель установки ClickOnce 1000 Ограничения ClickOnce 1001 Простая публикация ClickOnce 1002 Настройка издателя и продукта 1003 Запуск мастера публикации 1004 Развернутая файловая структура 1008 Установка приложения ClickOnce 1009 Обновление приложения ClickOnce 1010 Дополнительные параметры ClickOnce 1011 Версия публикации 1011 Обновления 1012 Ассоциации файлов 1013 Параметры публикации 1014 Резюме 1015 Предметный указатель 1016
Об авторе Мэтью МакДональд — автор, преподаватель и обладатель звания Microsoft MVP. Он написал свыше десятка книг по программированию в .NET, включая Pro Silverlight 3 in C# (Silverlight 3 с примерами на С# для профессионалов, ИД "Вильяме", 2010 г.), Pro ASP.NET 3.5 in C# [Microsoft ASP.NET 3.5 с примерами на С# 2008 для профессионалов, 2-е изд., ИД "Вильяме", 2008 г.), а также предыдущее издание этой книги — Pro WPF in С# 2008 [WPF: Windows Presentation Foundation в .NET 3.5 с примерами на С# 2008 для профессионалов, 2-е изд., ИД "Вильяме", 2008 г.). Проживает в Торонто с женой и двумя дочерьми. 0 техническом рецензенте Фабио Клаудио Феррачати — плодовитый писатель на темы передовых технологий. Фабио внес вклад в более чем десяток книг по .NET, C#, Visual Basic и ASP.NET. Имеет звание .NET Microsoft Certified Solution Developer (MCSD) и живет в Риме. Благодарности Ни один автор не может завершить книгу без коллектива помощников. Я глубоко признателен всей команде из Apress, включая Энн Коллетт (Anne Collett), которая сопровождала это издание на протяжении всей работы, Ким Уимпсет (Kim Wimpsett) и Мэрилин Смит (Marylin Smith), которые быстро и качественно выполняли редактирование текста, а также многим другим людям, которые занимались версткой, рисованием иллюстраций и вычиткой окончательной копии. Особую признательность хочу выразить Гарри Корнеллу (Gary Cornell) за его неоценимые консультации по проекту. Фабио Клаудио Феррачати и Кристоф Насарре (Christophe Nasarre) заслужили моей искренней благодарности за проницательные и поучительные комментарии. Я также благодарен легиону преданных блогеров из разных команд WPF, которые никогда не забывали пролить свет на наиболее темные места WPF. Настоятельно рекомендую всем, кто хочет узнать больше о будущем WPF, следить за их записями. Наконец, я бы никогда не написал ни одной книги без поддержки жены и следующих замечательных людей: Нора, Разя, Пол и Хамид. Спасибо вам всем!
Введение Платформа .NET принесла с собой небольшую лавину новых технологий. Появился совершенно новый способ написания веб-приложений (ASP.NET), совершенно новый способ подключения к базам данных (ADO.NET), новые безопасные к типам языки (С# и VB.NEH4) и управляемая исполняющая среда (CLR). Не последнее место занимала и технология Windows Forms — библиотека классов для построения Windows- приложений. Хотя Windows Forms — зрелый и полнофункциональньгй набор инструментов, он был тесно привязан к некоторым частям внутреннего устройства Windows, которые не слишком изменились за последние 10 лет. Что более существенно, при создании визуального представления стандартных пользовательских интерфейсных элементов, таких как кнопки, текстовые поля, флажки и т.п., Windows Forms полагается на Windows API. В результате его ингредиенты мало поддаются настройке и изменениям. Например, чтобы построить стилизованную блестящую кнопку, придется создать специальный элемент управления и нарисовать каждый аспект этой новой кнопки (во всех разных состояниях), используя низкоуровневую модель рисования. Хуже того, обычные окна разрезаются на отдельные области, и каждому элементу управления отводится собственная такая область. В результате не существует такого хорошего способа рисования в одном элементе управления (например, эффекта свечения под кнопки), чтобы он распространялся на область, принадлежащую другому элементу. И не стоит даже думать о создании анимационных эффектов вроде вращающегося текста, мерцающих кнопок, сворачивающихся окон или активных предварительных просмотров, потому что каждая-деталь должна быть нарисована вручную. В Windows Presentation Foundation (WPF) эта ситуация изменилась за счет ввода модели с совершенно другим устройством. Хотя платформа WPF включает знакомые стандартные элементы управления, она рисует каждый текст, контур и фон самостоятельно. В результате WPF может предоставить намного более мощные средства, которые позволяют изменить визуализацию любой части экранного содержимого. С помощью этих средств можно изменить стиль обычных элементов управления, таких как кнопки, часто даже без написания кода. Кроме того, можно применять трансформации объектов для вращения, растяжения, масштабирования и сдвига любой части пользовательского интерфейса, и даже использовать встроенную систему анимации WPF, чтобы делать все это прямо на глазах пользователя. И поскольку механизм WPF визуализирует содержимое окна как часть одной операции, он может обрабатывать неограниченное количество слоев перекрывающихся элементов, даже имеющих нерегулярную форму и частичную прозрачность. В основе WPF лежит мощная инфраструктура, основанная на DirectX — API- интерфейсе графики с аппаратным ускорением, который обычно используется в современных компьютерных играх. Это означает возможность применения развитых графических эффектов, не платя за это производительностью, как это было в Windows Forms. Фактически даже становятся доступными такие расширенные средства, как поддержка видеофайлов и трехмерное содержимое. Используя эти средства (при наличии хорошего инструмента графического дизайна), можно создавать бросающиеся в глаза пользовательские интерфейсы и визуальные эффекты, которые были просто невозможны в Windows Forms.
Введение 21 Хотя новейшие средства видео, анимации и 3-D часто привлекают максимум внимания в WPF, важно отметить, что WPF можно применять для построения обычных Windows-приложений со стандартными элементами управления и привычным внешним видом. Фактически использовать стандартные элементы управления в WPF так же легко, как и в Windows Forms. Более того, WPF расширяет средства, адресованные именно бизнес-разработчикам, включая значительно усовершенствованную модель привязки данных, набор классов для печати содержимого и управления очередями печати, а также средства работы с документами для отображения огромных объемов форматированного текста. Доступна даже модель для построения приложений на основе страниц, которые гладко работают в Internet Explorer и могут запускаться с веб-сайта — и все это без привычных предупреждений о безопасности или надоедливых приглашений к установке. Вообще говоря, WPF комбинирует лучшее из мира Windows-разработки с новейшими технологиями для построения современных, графически развитых пользовательских интерфейсов. Хотя приложения Windows Forms будут еще жить долгие годы, разработчикам, приступающим к новым проектам Windows, сначала стоит обратить внимание HaWPF. Об этой книге Эта книга представляет собой углубленное руководство по WPF для профессиональных разработчиков, знакомых с платформой .NET, языком С# и средой разработки Visual Studio. Опыт работы с предыдущими версиями WPF не обязателен, хотя новые средства в книге специально выделены во врезках "Что нового?" в начале каждой главы. Книга предлагает полное описание каждого из основных средств WPF — от XAML (языка разметки, используемого для определения пользовательских интерфейсов WPF) до трехмерного рисования и анимации. По ходу чтения вы ознакомитесь с кодом, который включает работу с другими средствами .NET Framework, такими как классы ADO.NET, которые служат для запросов к базе данных. Эти средства здесь не рассматриваются. За дополнительной информацией о средствах .NET, которые не являются специфичными для WPF, обращайтесь к соответствующим книгам. Обзор глав Эта книга включает в себя 33 главы. Если вы только начинаете знакомство с WPF, лучше читайте их по порядку, поскольку более поздние главы опираются на приемы, продемонстрированные в ранних. Ниже приводятся краткие описания всех глав. Глава 1. Введение в WPF. Описана архитектура WPF, внутренние механизмы DirectX, а также новая, независимая от устройства система измерения, которая автоматически изменяет размеры пользовательских интерфейсов. Глава 2. XAML. Рассматривается стандарт XAML, который используется для определения пользовательских интерфейсов. Будет показано, зачем он был создан и как работает, а также, как создавать базовые окна WPF с помощью различных подходов к кодированию. Глава 3. Компоновка. Дается углубленное представление панелей компоновки, которые позволяют организовать элементы в окне WPF Будут рассматриваться различные стратегии компоновки и строится некоторые распространенные типы окон. Глава 4. Свойства зависимости. Описано использование в WPF свойств зависимости для обеспечения поддержки таких ключевых средств, как привязка данных и анимация.
22 Введение Глава 5. Маршрутизируемые события. Рассматривается использование в WPF маршрутизации событий с пузырьковым распространением и туннелированием через элементы пользовательского интерфейса. В главе также содержится описание базового набора событий мыши, клавиатуры и сенсорных панелей, поддерживаемых всеми элементами WPF. Глава 6. Элементы управления. Описаны элементы управления, знакомые каждому разработчику Windows, такие как кнопки, текстовые поля и метки, и их воплощение в WPF. Глава 7. Класс Application. Рассматривается модель приложений WPF. Будет показано, как создавать приложения одного экземпляра и приложения WPF, основанные на документах. Глава 8. Привязка элементов. Объясняется привязка данных в WPF Будет показано, как привязать объекты любого типа к пользовательскому интерфейсу. Глава 9. Команды. Описана модель команд WPF, которая позволяет связывать несколько элементов управления с одинаковым логическим действием. Глава 10. Ресурсы. Показано, как с помощью ресурсов встраивать двоичные файлы в сборку и многократно использовать важные объекты по всему пользовательскому интерфейсу. Глава 11. Стили и поведения. Рассматривается система стилей WPF, которая позволяет применять набор общих значений свойств к целой группе элементов управления. Глава 12. Фигуры, кисти и трансформации. Описана модель двухмерного рисования в WPF. Будет показано, как создавать фигуры, изменять элементы с помощью трансформаций и получать экзотические эффекты с помощью градиентов, укладки плиткой и изображениями. Глава 13. Классы Geometry и Drawing. Более глубоко рассматривается двухмерное рисование. Будет показано, как создавать сложные пути, включающие дуги и кривые, а также эффективно использовать сложную графику. Глава 14. Эффекты и класс Visual. Рассматривается программирование низкоуровневой графики. Будет показано, как применять эффекты в стиле Photoshop с помощью построителей текстур, вручную создавать растровые изображения, а также использовать визуальный уровень WPF для оптимизации рисования. Глава 15. Основы анимации. Описана платформа анимации WPF, которая позволяет интегрировать динамические эффекты в приложение, используя прямолинейную декларативную разметку. Глава 16. Расширенная анимация. Рассматриваются более сложные приемы анимации, такие как анимация ключевого кадра, анимация, основанная на пути, и анимация на основе кадров. Также предлагается детальный пример, демонстрирующий создание и управление динамической анимацией в коде. Глава 17. Шаблоны элементов управления. Показано, как придать совершенно новый вид (и новое поведение) любому элементу управления WPF, подключая специализированный шаблон. Также описано, как с помощью шаблонов создавать приложения со сменными обложками. Глава 18. Пользовательские элементы. Посвящена расширению существующих элементов управления WPF и созданию собственных. Будет предложено несколько примеров, включая основанный на шаблоне селектор цвета, переворачиваемую па-
Введение 23 нель, специальный контейнер компоновки и декоратор, который выполняет специальное рисование. Глава 19. Привязка данных. Рассматривается, как извлекать информацию из базы данных, вставлять в специальные объекты данных и привязывать эти объекты к элементам управления WPF. Также описаны приемы повышения производительности больших связанных с данными списков посредством виртуализации, а также перехват ошибок редактирования за счет проверки достоверности. Глава 20. Форматирование привязанных данных. Описаны некоторые трюки для превращения неформатированных данных в развитое экранное представление, включающее изображения, элементы управления и эффекты выбора. Глава 21. Представления данных. Объясняется использование представления в окне, привязанном к данным, для навигации по списку элементов данных и применения фильтрации, сортировки и группировки. Глава 22. Элементы управления ListView, TreeView и DataGrid. Дается экскурс по многофункциональным элементам управления WPF, включая ListView, TreeView и DataGrid. Глава 23. Окна. Рассматривается работа окон в WPF. Будет показано, как создавать окна неправильной формы и использовать "стеклянные" эффекты Windows Vista. Кроме того, будет реализовано большинства средств Windows 7 за счет настройки списков часто используемых элементов в панели задач, миниатюр и налагаемых значков. Глава 24. Страницы и навигация. Описано построение страниц в WPF и отслеживание хронологии навигации. Также будет показано, как строить основанные на браузере приложения WPF, которые могут быть запущены с веб-сайта. Глава 25. Меню, панели инструментов и ленты. Посвящена командно-ориентированным элементам управления, таким как меню и панели инструментов. Также демонстрируется более современный интерфейс на основе свободного загружаемого элемента управления Ribbon. Глава 26. Звук и видео. Описана поддержка мультимедиа в WPF. Будет показано, как управлять воспроизведением звука и видео, и как реализовать синхронизированные анимации и живые эффекты. Глава 27. Трехмерная графика. Рассматривается поддержка рисования трехмерных фигур в WPF. Будет показано, как создавать, трансформировать и анимировать трехмерные объекты, а также, как помещать интерактивные двухмерные элементы управления на трехмерные поверхности. Глава 28. Документы. Описана поддержка форматированных документов в WPF. Будет показано, как использовать потоковые документы для представления больших объемов текста в наиболее читабельном виде и фиксированные документы для отображения страниц, готовых к печати. Кроме того, рассматривается применение элемента управления RichTextBox для редактирования документа. Глава 29. Печать. Представлена модель печати WPF, которая позволяет выводить текст и фигуры в печатный документ. Будет также показано, как управлять настройками страниц и очередями печати. Глава 30. Взаимодействие с Windows Forms. Описаны способы комбинирования содержимого WPF и Windows Forms в пределах одного приложения и даже одного окна.
24 Введение Глава 31. Многопоточность. Рассматривается создание отзывчивых приложений WPF, которые выполняют длительные задачи в фоновом режиме. Глава 32. Модель дополнений. Показано, как создавать расширяемое приложение, которое может динамически обнаруживать и подгружать отдельные компоненты. Глава 33. Развертывание ClickOnce. Рассматриваются вопросы, связанны с развертыванием приложений WPF с помощью технологии ClickOnce. Что необходимо для чтения этой книги Для того чтобы запустить приложение WPF, на компьютере должна быть установлена система Windows 7, Windows Vista или Windows XP с Service Pack 2. Также понадобится .NET Framework 4. Чтобы создавать приложения WPF (и открывать примеры проектов, включенные в эту книгу), необходима среда Visual Studio 2010, которая включает .NET Framework 4. Существует еще одна возможность. Вместо использования любой версии Visual Studio строить и тестировать приложения WPF можно с помощью инструмента графического дизайна Expression Blend. В целом, Expression Blend предназначен для дизайнеров графики, которые большую часть времени занимаются созданием внешнего вида, в то время как Visual Studio — идеальная среда для работы программистов, пишущих код приложений. В книге предполагается применение Visual Studio. За дополнительными сведениями об Expression Blend следует обращаться к одной из специализированных книг. (Кстати, для создания приложений с помощью WPF 4 понадобится Expression Blend 4.) Исходный код примеров Исходный код всех рассматриваемых в настоящей книге примеров доступен на вебсайте издательства по адресу http://www.williamspublishing.com/. От издательства Вы, читатель этой книги, и есть главный ее критик и комментатор. Мы ценим ваше мнение и хотим знать, что было сделано нами правильно, что можно было сделать лучше и что еще вы хотели бы увидеть изданным нами. Нам интересно услышать и любые другие замечания, которые вам хотелось бы высказать в наш адрес. Мы ждем ваших комментариев и надеемся на них. Вы можете прислать нам бумажное или электронное письмо, либо просто посетить наш Web-сервер и оставить свои замечания там. Одним словом, любым удобным для вас способом дайте нам знать, нравится или нет вам эта книга, а также выскажите свое мнение о том, как сделать наши книги более интересными для вас. Посылая письмо или сообщение, не забудьте указать название книги и ее авторов, а также ваш обратный адрес. Мы внимательно ознакомимся с вашим мнением и обязательно учтем его при отборе и подготовке к изданию последующих книг. Наши координаты: E-mail: info@williamspublishing.com WWW: http://www.williamspublishing.com Информация для писем из: России: 127055, г. Москва, ул. Лесная, д. 43, стр. 1 Украины: 03150, Киев, а/я 152
ГЛАВА 1 Введение в WPF Windows Presentation Foundation (WPF) — это графическая система отображения для Windows. Платформа WPF спроектирована для .NET под влиянием таких современных технологий отображения, как HTML и Flash, и использует аппаратное ускорение. Она также является наиболее радикальным изменением в пользовательском интерфейсе Windows со времен Windows 95. В этой главе вы ознакомитесь с архитектурой WPF. Вы узнаете, как она справляется с различными разрешениями экрана, и получите общее представление о ее сборках и классах. Также будут рассмотрены новые средства, добавленные к WPF 4. Что нового? Если вы — опытный разработчик WPF, то можете сразу перейти к разделу "WPF 4" настоящей главы, в котором подытожены изменения, произошедшие в последнем выпуске WPF Эволюция графики в Windows Трудно оценить важность WPF, не принимая во внимание тот факт, что разработчики Windows-приложений в течение более 15 лет пользовались, по сути, одной и той же технологией отображения. Стандартное Windows-приложение при создании пользовательского интерфейса полагается на две основополагающие части операционной системы Windows: • User32 обеспечивает знакомый внешний вид и поведение таких элементов, как окна, кнопки, текстовые поля и т.п.; • GDI/GDI+ предоставляет поддержку рисования фигур, текста и изображений за счет дополнительного усложнения (и часто неважной производительности). С годами обе технологии совершенствовались, и API-интерфейсы, используемые разработчиками для взаимодействия с ними, значительно менялись. Но как бы ни разрабатывалось приложение — с помощью .NET и Windows Forms, (в прошлом) Visual Basic 6 или кода C++ на основе MFC — "за кулисами" работают одни и те же части операционной системы Windows. Новые платформы просто предоставляют улучшенные оболочки для взаимодействия с User32 и GDI/GDI+. Они могут быть более эффективными, менее сложными, могут включать некоторые заранее подготовленные средства, чтобы не приходилось создавать их самостоятельно, однако они не могут преодолеть фундаментальные ограничения системных компонентов, разработанных более 10 лет назад. На заметку! Базовое разделение ответственности между User32 и GDI/GDI+ было заложено свыше 15 лет назад в Windows 3.0. Конечно, часть User32 в те времена была просто User, поскольку тогда программное обеспечение еще не вошло в 32-разрядный мир.
26 Глава 1. Введение в WPF DirectX: новый графический механизм В Microsoft разработали один обходной путь для преодоления ограничений, присущих библиотекам User32 и GDI/GDI+. Этим путем является DirectX. Он начинался как "топорный", полный ошибок инструментальный набор для создания игр на платформе Windows. Главной его целью была скорость, и потому Microsoft тесно сотрудничала с производителями видеокарт, чтобы обеспечить для DirectX аппаратную поддержку, необходимую для отображения сложных текстур, специальных эффектов вроде частичной прозрачности и трехмерной графики. За годы, прошедшие с момента появления (вскоре после выхода Windows 95), механизм DirectX обрел зрелость. Теперь это неотъемлемая часть Windows, которая включает поддержку всех современных видеокарт. Однако API-интерфейс DirectX по-прежнему несет в себе наследие своих корней как средства для разработки игр. Из-за присущей DirectX сложности он почти никогда не использовался в традиционных Windows- приложениях (в частности, в бизнес-приложениях). Технология WPF в корне меняет ситуацию. Лежащая в основе WPF графическая технология — это не GDI/GDI+. Теперь это DirectX. Примечательно, что приложения WPF используют DirectX независимо от создаваемого типа пользовательского интерфейса. Это значит, что создается ли сложная трехмерная графика (DirectX's forte), или просто рисуются кнопки и простой текст — вся работа по рисованию проходит через конвейер DirectX. В результате даже самые заурядные бизнес-приложения могут использовать богатые эффекты вроде прозрачности и сглаживания. Также получается выигрыш от аппаратного ускорения, и это означает, что DirectX передает как можно больше работы узлу обработки графики (graphics processing unit — GPU), который представляет собой отдельный процессор на видеокарте. На заметку! Технология DirectX более эффективна, поскольку оперирует высокоуровневыми конструкциями вроде текстур и градиентов, которые могут отображаться непосредственно видеокартой. Компонент GDI/GDH- на это не способен, поэтому ему приходится преобразовывать их в инструкции рисования пикселей, и потому отображение проходит намного медленнее даже на современных видеокартах. Один компонент, который остается на сцене (в ограниченной степени) — это User32. Это объясняется тем, что WPF по-прежнему полагается на User32 в отношении таких служб, как обработка и маршрутизация ввода, а также определение того, какое приложение какой частью экрана владеет. Однако все рисование производится через DirectX. На заметку! Это наиболее существенное изменение в WPR Технология WPF — это не оболочка для GDI/GDI+. На самом деле это его замена — отдельный уровень, работающий через DirectX. Аппаратное ускорение и WPF Возможно, вам известно, что видеокарты различаются между собой в плане поддержки специализированных средств визуализации и оптимизации. К счастью, проблемой это не является, поскольку WPF обладает способностью выполнять всю работу с использованием программных вычислений вместо того, чтобы полагаться на встроенную поддержку видеокарты. На заметку! В отношении программной поддержки WPF существует одно исключение. Из-за слабой поддержки драйверов WPF выполняет сглаживание трехмерной графики только в случае, если приложение запущено под управлением Windows Vista или Windows 7 (и есть встроенный драйвер WDDM для установленной видеокарты).
Глава 1. Введение в WPF 27 Это значит, что при рисовании трехмерных фигур на компьютере с Windows XP вместо гладких линий будут получены ступенчатые ломаные. Однако для двумерной графики сглаживание обеспечивается всегда, независимо от операционной системы и поддержки драйверов. Наличие мощной видеокарты не дает абсолютной гарантии, что вы получите максимальную, с аппаратной поддержкой производительность на WPF. Программное обеспечение также играет важную роль. Например, WPF не может обеспечить аппаратного ускорения на видеокартах, если используются устаревшие драйверы. (Для устаревших видеокарт, такие драйверы, скорее всего, будут единственно доступными.) Технология WPF также обеспечивает более высокую производительность в средах операционных систем Windows Vista и Windows 7, где она может пользоваться преимуществами новой модели дисплейных драйверов Windows (Windows Display Driver Model — WDDM). Модель WDDM предлагает несколько важных усовершенствований по сравнению с Windows XP Display Driver Model (XPDM). Что более важно, WDDM позволяет запланировать несколько операций GPU одновременно и отображать страницы памяти видеокарты на обычную системную память, если вся память видеокарты израсходована. Запомните в качестве главного эмпирического правила: WPF предоставляет некоторого рода аппаратное ускорение всем драйверам WDDM и драйверам XPDM, созданным после ноября 2004 г., когда Microsoft издала новые руководства по разработке драйверов. Разумеется, уровень поддержки отличается. Когда инфраструктура WPF запускается в первый раз, она оценивает видеокарту и назначает ей рейтинг от 0 до 2, как описано во врезке "Уровни WPF". Среди обещаний, связанных с WPF, было и то, что вам не нужно беспокоиться о деталях и сложностях, связанных со специфическим аппаратным обеспечением. Технология WPF достаточно интеллектуальна, чтобы по возможности использовать аппаратную оптимизацию, но в случае неудачи все будет обработано программно. Поэтому если вы запустите WPF-приложение на компьютере с унаследованной видеокартой, интерфейс будет выглядеть так, как он был разработан. Конечно, программные альтернативы могут оказаться значительно медленнее, так что вы столкнетесь с тем, что компьютеры со старыми видеокартами не очень хорошо отрабатывают расширенные приложения WPF — особенно те, что включают сложную анимацию или другие сложные графические эффекты. На практике может быть принято решение упростить некоторые сложные эффекты в пользовательском интерфейсе, в зависимости от уровня аппаратной поддержки, доступной клиенту (определяется свойством RenderCapability.Tier). На заметку! Целью WPF является взвалить на видеокарту как можно больше работы, чтобы сложные графические процедуры ограничивались возможностями визуализации (узлом обработки графики), а не вычислительной мощностью процессора (центральным процессором компьютера). При таком подходе центральный процессор высвобождается для другой работы, видеокарта используется максимально эффективно и появляется возможность пользоваться преимуществами новых видеокарт по мере их появления. Уровни WPF Видеокарты значительно различаются между собой. Когда WPF оценивает видеокарту, то учитывает множество факторов, включая объем памяти видеокарты, поддержку построителей текстур (встроенные процедуры вычисления пиксельных эффектов наподобие прозрачности), вершинных построителей текстур (встроенные процедуры вычисления значений вершин треугольника, которые применяются при текстурировании трехмерных объектов). На основе всех этих деталей определяется значение уровня визуализации WPF.
28 Глава 1. Введение в WPF WPF распознает три уровня визуализации. 1. Уровень визуализации 0. Видеокарта не предоставляет никакого аппаратного ускорения. Это соответствует версии DirectX ниже 7.0. 2. Уровень визуализации 1. Видеокарта обеспечивает частичное аппаратное ускорение. Это соответствует версии DirectX выше 7.0, но ниже 9.0. 3. Уровень визуализации 2. Все средства, которые могут быть ускорены аппаратно, будут ускорены. Это отвечает версии DirectX 9.0 и выше. В некоторых ситуациях требуется программно проверить текущий уровень визуализации, чтобы выборочно отключить некоторые сложные графические средства на менее мощных картах. Для этого используется статическое свойство Tier класса System.Windows.Media. RenderCapability. Но здесь должен быть предпринят один трюк. Чтобы извлечь значение уровня из свойства Tier, необходимо выполнить сдвиг на 16 бит, как показано ниже: int renderingTier = (RenderCapability.Tier » 16); if (renderingTier == 0) {...} else if (renderingTier == 1) {...} Такое проектное решение допускает расширяемость. В будущих версиях WPF другие биты свойства Tier могут быть использованы для сохранения информации о поддержке других свойств, создавая в результате подуровни. За дополнительной информацией об аппаратно ускоряемых средствах WPF для уровней 1 и 2, а также за списками видеокарт соответствующих уровней обращайтесь по адресу http://msdn. microsoft.com/ru-ru/library/ms742196(v=VS. 100) .aspx. WPF: высокоуровневый API-интерфейс Даже если бы единственным достоинством WPF было аппаратное ускорение через DirectX, это уже стало бы значительным усовершенствованием, хоть и не революционным. Однако WPF на самом деле включает целый набор высокоуровневых служб, ориентированных на прикладных программистов. Ниже приведен список некоторых наиболее существенных изменений, которые привнесла с собой технология WPF в мир программирования Windows-приложений. • Веб-подобная модель компоновки. Вместо того чтобы фиксировать элементы управления на месте с определенными координатами, WPF поддерживает гибкий поток, размещающий элементы управления на основе их содержимого. В результате получается пользовательский интерфейс, который может быть адаптирован для отображения высоко динамичного содержимого или к разным языкам. • Богатая модель рисования. Вместо рисования пикселей в WPF вы имеете дело с примитивами — базовыми фигурами, блоками текста и прочими графическими ингредиентами. Кроме того, доступны такие новые средства, как действительно прозрачные элементы управления, возможность укладывания друг на друга множества уровней с разной степенью прозрачности, а также встроенная поддержка трехмерной графики. • Развитая текстовая модель. После многих лет нестандартной обработки текстов WPF наконец-то предоставляет Windows-приложениям возможность отображения расширенного стилизованного текста в любом месте пользовательского интерфейса. И если нужно отображать значительные объемы текста, для повышения читабельности можно воспользоваться развитыми средствами отображения документов, такими как переносы, разбиение на колонки и выравнивание.
Глава 1. Введение в WPF 29 • Анимация как первоклассная программная концепция. В WPF нет необходимости использовать таймер для того, чтобы заставить форму перерисовать себя. Вместо этого доступна анимация — неотъемлемая часть платформы. Анимация определяется декларативными дескрипторами, и WPF запускает ее в действие автоматически. • Поддержка аудио и видео. Прежние инструментальные наборы для построения пользовательских интерфейсов, такие как Windows Forms, были весьма ограничены в работе с мультимедиа. Однако WPF включает поддержку воспроизведения любого аудио- или видеофайла, поддерживаемого проигрывателем Windows Media, позволяя воспроизводить более одного медиафайла одновременно. Что еще больше впечатляет — WPF предоставляет в ваше распоряжение инструменты для интеграции видеосодержимого в остальную часть пользовательского интерфейса, позволяя выполнять такие экзотические трюки, как размещение видеоокна на поверхности вращающегося трехмерного куба. • Стили и шаблоны. Стили позволяют стандартизировать форматирование и многократно использовать его по всему приложению. Шаблоны дают возможность изменить способ отображения элементов, даже таких основополагающих, как кнопки. Построение интерфейса с обложками еще никогда не было таким простым. • Команды. Большинству пользователей известно, что не имеет значения, откуда они инициируют команду открытия (Open) — через меню или панель инструментов; конечный результат один и тот же. Теперь эта абстракция доступна коду — можно определять команды приложения в одном месте и привязывать их к множеству элементов управления. • Декларативный пользовательский интерфейс. Хотя можно конструировать окно WPF в коде, в Visual Studio используется другой подход. Содержимое каждого окна сериализуется в виде XML-дескрипторов в документе XAML. Преимущество состоит в том, что пользовательский интерфейс полностью отделяется от кода, и дизайнеры графики могут использовать профессиональные инструменты для редактирования файлы XAML, улучшая внешний вид всего приложения. (XAML — это сокращение от Extensible Application Markup Language (расширяемый язык разметки приложений), который описан в главе 2.) • Приложения на основе страниц. Используя WPF, можно строить браузер-подобные приложения, которые позволяют перемещаться по коллекции страниц, оснащенной кнопками навигации "вперед" и "назад". WPF автоматически обрабатывает все сложные детали, такие как хронология посещения страниц. Проект можно даже развернуть в виде браузерного приложения, которое выполняется внутри Internet Explorer. Технология Windows Forms продолжает существовать WPF — это платформа для будущего разработки пользовательских интерфейсов Windows-приложений. Однако она не заменит полностью Windows Forms. Во многих отношениях Windows Forms представляет собой кульминацию предшествующего поколения технологий отображения, построенных на основе GDI/GDI+ и User32. Так какую же платформу следует использовать при разработке нового Windows- приложения? Если вы начинаете с нуля, идеальным выбором будет WPF, поскольку она предлагает лучшие возможности для будущих расширений и лучшую жизнеспособность. Аналогично, если нужно одно из средств, которые в WPF доступны, a Windows Forms — нет, например, трехмерное рисование или страничная организация приложений, то имеет смысл перейти на новую платформу. С другой стороны, если вы сделали существенные вложения в бизнес-приложение на основе Windows Forms, то не стоит
30 Глава 1. Введение в WPF перекодировать его на WPF. В ближайшие годы поддержка платформы Windows Forms будет продолжаться. Возможно, лучшая часть истории состоит в том, что в Microsoft предприняли значительные усилия для построения уровня взаимодействия между WPF и Windows Forms (он играет роль, аналогичную уровню взаимодействия, который позволяет приложениям .NET продолжать пользоваться унаследованными компонентами СОМ). В главе 30 вы узнаете о том, как использовать эту поддержку элементов управления Windows Forms в приложениях WPF и наоборот WPF предлагает аналогичную надежную поддержку интеграции с более старыми приложениями в стиле Win32. DirectX также продолжает существовать Существует одна область, для которой WPF не слишком хорошо подходит — создание приложений с требованиями к графике реального времени, таких как эмуляторы сложных физических процессов или современные интерактивные игры. Поскольку для такого рода приложений нужна максимально возможная видеопроизводительность, необходимо программировать на более низком уровне и использовать DirectX напрямую. Библиотеки управляемого кода .NET для программирования DirectX доступны для загрузки на сайте http://msdn.microsoft.com/directx. На заметку! Начиная с WPF 3.5 SP1, в Microsoft начали разрушать некоторые границы между DirectX и WPF. Теперь можно создать содержимое DirectX и поместить его внутри приложения WPF. Фактически, можно даже создать на его основе кисть и использовать ее для рисования элемента управления WPF, или же сделать ее текстурой и отобразить на трехмерную поверхность WPF Тема интеграции WPF и DirectX выходит за рамки настоящей книги, поэтому обращайтесь за этим в документацию MSDN, начиная с http://msdn.microsoft.com/ru-ru/ library/system.windows.interop.d3dimage(v=VS.100) .aspx. Silverlight Как и .NET Framework в целом, WPF представляет собой технологию, ориентированную на Windows. Это значит, что приложения WPF могут использоваться только на компьютерах, работающих под управлением операционной системы Windows. Приложения WPF, основанные на браузерах, ограничены аналогичным образом — они работают только на компьютерах Windows, хотя поддерживают браузеры и Internet Explorer, и Firefox. Эти ограничения не изменятся: в конце концов, отчасти целью Microsoft в отношении WPF является использование широких возможностей компьютеров Windows и сохранение инвестиций в такие технологии, как DirectX. Однако технология Silverlight спроектирована как подмножество платформы WPF, работает в любом современном браузере (Firefox, Google Chrome и Safari) за счет использования подключаемого модуля, и открыта для других операционных систем, таких как Linux и Mac OS. Этот амбициозный проект вызвал значительный интерес среди разработчиков. Во многих отношениях технология Silverlight основана на WPF и включает в себя многие соглашения WPF (наподобие разметки XAML, которая рассматривается в следующей главе). Тем не менее, Silverlight не охватывает ряд областей, среди которых трехмерная графика и отображение форматированных документов. В будущих выпусках Silverlight могут появиться некоторые новые средства, но наиболее сложные из них — вряд ли. Конечной целью Silverlight является предоставление мощного ориентированного на разработчика конкурента Adobe Flash. Однако Flash обладает ключевым преимуществом — он используется в веб-приложениях повсеместно, и подключаемые модули Flash установлены почти везде. Чтобы заставить разработчиков перейти на новую, менее устоявшуюся технологию, Microsoft придется снабдить Silverlight средствами следующего
Глава 1. Введение в WPF 31 поколения, обеспечить основательную совместимость и непревзойденную проектную поддержку. На заметку! Silverlight имеет две потенциальные аудитории: веб-разработчики, которые хотят создавать более интерактивные приложения, и разработчики Windows, которые хотят расширить свои приложения. Более подробно технология Silverlight описана в книге Silverlight 3 с примерами на С# для профессионалов (ИД "Вильяме", 2010 г.). Можно также посетить веб-сайт http://silverlight.net. Независимость от разрешения Традиционные Windows-приложения связаны определенными предположениями относительно разрешения экрана. Обычно разработчики рассчитывают на стандартное разрешение монитора (вроде 1024x768 пикселей) и проектируют свои окна с учетом этого, стараясь обеспечить разумное поведение при изменении размеров в большую и меньшую сторону. Проблема в том, что пользовательский интерфейс в традиционных Windows- приложениях не является масштабируемым. В результате, если вы используете монитор с высоким разрешением, который располагает пиксели более плотно, окно приложения становится меньше и читать текст в нем труднее. Эта проблема особенно актуальна для новых мониторов, которые имеют высокую плотность пикселей и соответственно работают с более высоким разрешением. Например, легче встретить мониторы (особенно на портативных компьютерах), которые имеют плотность пикселей в 120 dpi или 144 dpi (точек на дюйм), чем более традиционные 96 dpi. При их встроенном разрешении эти мониторы располагают пиксели более плотно, создавая напрягающие глаз мелкие элементы управления и текст. В идеале приложения должны использовать более высокую плотность пикселей, чтобы отобразить больше деталей. Например, монитор с высоким разрешением может отображать одинакового размера значки панели инструментов, но использовать дополнительные пиксели для отображения мелкой графики. Подобным образом можно сохранить некоторую базовую компоновку, но обеспечить более высокую четкость деталей. По разным причинам такое решение было невозможно в прошлом. Хотя можно изменять размер графического содержимого, нарисованного в GDI/GDI+, компонент User32 (который генерирует визуальное представление распространенных элементов управления) не поддерживает реального масштабирования. WPF не страдает от этой проблемы, потому что самостоятельно визуализирует все элементы пользовательского интерфейса — от простых фигур до таких распространенных элементов управления, как кнопки. В результате если вы создаете кнопку шириной в 1 дюйм на обычном мониторе, она останется шириной в 1 дюйм и на мониторе с высоким разрешением. WPF просто визуализирует ее более детализировано, с большим количеством пикселей. Так выглядит картина в целом, но нужно уточнить еще несколько деталей. Самое важное, что следует осознать — WPF базирует свое масштабирование на системной установке DPI, а не на DPI физического дисплейного устройства. Это совершенно логично — в конце концов, если вы отображаете приложение на 100-дюймовом проекторе, то, скорее всего, отойдете подальше на несколько шагов и будете ожидать увидеть огромную версию окон. Конечно, не желательно, чтобы WPF масштабировал приложение, уменьшая его до "нормального" размера. Аналогично, если вы используете портативный компьютер с дисплеем высокого разрешения, то хотите увидеть несколько уменьшенные окна; это цена, которую приходится платить за то, чтобы уместить всю информацию на маленьком экране. Более того, у разных пользователей разные предпочтения на
32 Глава 1. Введение в WPF этот счет. Некоторым нужны расширенные подробности, в то время как другие хотят увидеть больше содержимого. Так каким же образом WPF определяет, насколько большим должно быть окно приложения? Краткий ответ состоит в том, что при вычислении размеров WPF использует системную установку DPI. Но чтобы понять, как это в действительности работает, необходимо более детально ознакомиться с системой измерений WPF. Единицы WPF Окно WPF и все элементы внутри него измеряются в независимых от устройства единицах. Такая единица определена как 1/96 дюйма. Чтобы понять, что это означает на практике, нужно рассмотреть пример. Предположим, что вы создаете в WPF маленькую кнопку размером 96x96 единиц. Если вы используете стандартную установку Windows DPI (96 dpi), то каждая независимая от устройства единица измерения соответствует одному реальному физическому пикселю. Это потому, что WPF использует следующее вычисление: [Размер в физических единицах] = [Размер в независимых от устройства единицах] х [DPI системы] = 1/96 дюйма х 96 dpi = 1 пиксель По сути, WPF предполагает, что ему нужно 96 пикселей, чтобы отобразить один дюйм, потому что Windows сообщает ему об этом через системную настройку DPI. Однако в действительности это зависит от применяемого дисплейного устройства. Например, рассмотрим 20-дюймовый жидкокристаллический монитор с максимальным разрешением в 1600x1200 пикселей. Используя теорему Пифагора, вы можете вычислить плотность пикселей для этого монитора, как показано ниже: Гг_т л Vl6002 +12002 пикселей ^ пп ^ [DPI экрана] = = 100 dpi 19дюймов В этом случае плотность пикселей составляет 100 dpi — немного больше того, что предполагает Windows. В результате на этом мониторе кнопка размером 96x96 пикселей будет несколько меньше одного дюйма. С другой стороны, рассмотрим 15-дюймовый жидкокристаллический монитор с разрешением 1024x768 пикселей. Здесь плотность пикселей составит около 85 dpi, поэтому кнопка размером 96x96 пикселей окажется размером немного больше 1 дюйма. В обоих случаях, если вы уменьшите размер экрана (скажем, переключившись на разрешение 800x600), то кнопка (и любой другой экранный элемент) станет пропорционально больше. Причина в том, что системная установка DPI останется 96 dpi. Другими словами, Windows продолжает предполагать, что 96 пикселей составляют дюйм, несмотря на то, что при меньшем разрешении потребуется существенно меньше пикселей. Совет. Возможно, вам известно, что жидкокристаллические мониторы создаются с единственным разрешением, которое называется естественным разрешением. При более низком разрешении монитору приходится использовать интерполяцию, чтобы заполнить лишние пиксели, в это может вызвать нерезкость. Чтобы получить наилучшее качество изображения, всегда лучше использовать естественное разрешение. Если хотите иметь более крупные окна, кнопки и текст, рассмотрите вместо этого возможность модификации системной установки DPI (как описано далее). Системная установка DPI До сих пор пример кнопки WPF работал точно так же, как любой другой интерфейсный элемент в Windows-приложении любого иного типа. Отличие проявляется при из-
Глава 1. Введение в WPF 33 менении вашей системной установки DPI. В предыдущем поколении Windows это средство иногда называли крупными шрифтами. Это потому, что системная установка DPI влияет на размер системных шрифтов, часто оставляя прочие детали неизменными. На заметку! Многие Windows-приложения не полностью поддерживают увеличенные установки DPI. В худшем случае увеличение системной установки DPI может привести к появлению окон, в которых некоторое содержимое увеличено, а другое — нет, что может привести к утере части содержимого или даже к нефункциональным окнам. Здесь поведение WPF отличается. WPF воспринимает системную установку DPI естественным образом и без особых затрат. Например, если вы измените системную установку DPI на 120 dpi (распространенный выбор пользователей экранов с большим разрешением), WPF предполагает, что для заполнения дюйма пространства нужно 120 пикселей. WPF использует следующее вычисление для определения того, как он должен транслировать логические единицы в физические пиксели устройства: [Размер в физических единицах] = [Размер в независимых от устройства единицах] х [DPI системы] =1/96 дюйма х 120 dpi =1,25 пикселя Другими словами, когда вы устанавливаете системную настройку DPI в 120 dpi, то механизм визуализации WPF предполагает, что одна независимая от устройства единица измерения соответствует 1,25 пикселя. Если вы отображаете кнопку 96x96, то физический ее размер составит 120x120 пикселей (потому что 96 х 1,25 = 120). Именно такого результата вы и ожидаете — кнопка размером в 1 дюйм имеет такой же размер на мониторе с повышенной плотностью пикселей. Такое автоматическое масштабирование было бы не слишком полезным, если бы касалось только кнопок. Но WPF использует независимые от устройства единицы для всего, что отображает, включая фигуры, элементы управления, текст и любые другие ингредиенты, которые помещаются в окно. В результате можно изменять системную установку DPI, как вам заблагорассудится, и WPF незаметно подгонит размеры окон приложения. На заметку! В зависимости от системной установки DPI вычисляемый размер пикселя может быть выражен дробным значением. Можно предположить, что WPF просто округляет все размеры до ближайшего пикселя. Однако по умолчанию WPF поступает несколько иначе. Если грань элементов приходится на точку между пикселями, WPF использует сглаживание, чтобы размыть эту грань. Это может показаться странным решением, но на самом деле оно вполне оправдано. Элементы управления не обязательно должны иметь прямые четкие грани, если для их отображения применяется специально отрисованная графика, поэтому некоторая степень сглаживания все равно необходима. Шаги для изменения системной установки DPI зависят от операционной системы. В следующих разделах объясняется, что следует делать, в зависимости от используемой операционной системы. Windows XP 1. Щелкните правой кнопкой мыши на рабочем столе и выберите в контекстном меню пункт Свойства. 2. В открывшемся диалоговом окне перейдите на вкладку Параметры и щелкните на кнопке Дополнительно.
34 Глава 1. Введение в WPF 3. На вкладке Общие выберите в списке Масштаб (количество точек на дюйм) вариант Обычный размер (96 точек/дюйм) или Крупный размер A20 точек/дюйм). Это две рекомендованных опции для Windows XP, потому что специальные установки DPI, скорее всего, не будут поддерживаться старыми программами. Чтобы попробовать установить собственное значение DPI, выберите вариант Особые параметры. Затем можно указать определенное значение в процентах (например, 175% увеличивает стандартное значение 96 dpi до 168 dpi). Windows Vista 1. Щелкните правой кнопкой мыши на рабочем столе и выберите в контекстном меню пункт Персонализация. 2. В списке ссылок слева щелкните на Корректировка размеров шрифта (DPI). 3. Выберите один из переключателей 96 точек/дюйм и 120 точек/дюйм либо щелкните на кнопке Другой размер шрифта, чтобы указать специальное значение DPI. После этого можно задать значение в процентах (например, 175% увеличивает стандартное значение 96 dpi до 168 dpi). Кроме того, здесь имеется флажок Использовать масштабы в стиле Windows XP, который описан во врезке "Масштабирование DPI в Windows Vista и Windows 7". Windows 7 1. Щелкните правой кнопкой мыши на рабочем столе и выберите в контекстном меню пункт Персонализация. 2. В списке ссылок внизу слева щелкните на Экран. 3. Выберите один из переключателей Мелкий (опция по умолчанию), Средний или Крупный. Эти опции также описаны в процентах масштабирования A00%, 125% или 150%) и на самом деле соответствуют значениями 96 dpi, 120 dpi и 144 dpi. Первые две соответствуют стандартам, имеющимся в Windows Vista и Windows XP, а третья — несколько больше. В качестве альтернативы можно щелкнуть на ссылке Другой размер шрифта (точек на дюйм) и указать специальное значение масштаба, как показано на рис. 1.1 (например, 175% увеличивает стандартное значение 96 dpi до 168 dpi). Кроме того, здесь имеется флажок Использовать масштабы в стиле Windows XP, который описана во врезке "Масштабирование DPI в Windows Vista и Windows 7". Выбор масштаба ggj] Для установки масштаба выберите процентное соотношение из списка или переместите ползунок с Масштаб от обычного размера: 1 | 1 1 ' 0 1 Segoe 1Д 9 пт, 96 пикселей на дюйм льзовать масштабы в иле Windows № помощью мыши. 100% - 1 1 2 •1 3 • ОК ] [ Отмена ) Рис. 1.1. Изменение системной установки DPI
Глава 1. Введение в WPF 35 Масштабирование DPI в Windows Vista и Windows 7 Поскольку старые приложения печально известны отсутствием поддержки высоких значений DPI, в Windows Vista появился новый прием, который получил название масштабирование растровых изображений (bitmap scaling). В Windows 7 это средство также поддерживается. Если вы запускаете приложение, которое не поддерживает высоких значений DPI, то Windows изменяет размер содержимого окна до желаемого DPI, как если бы это было просто графическое изображение. Преимущество такого решения в том, что приложению кажется, что оно работает при стандартных 96 dpi. ОС Windows незаметно транслирует ввод (такой как щелчки кнопками мыши) и маршрутизирует его в правильное место соответствующей "реальной" координатной системы. Алгоритм масштабирования, используемый Windows, достаточно хорош — он старается избегать размытости граней и использует аппаратную поддержку видеокарты, когда это позволяет увеличить скорость, но это неизбежно приводит к некоторой общей размытости изображения. К тому же это имеет серьезные ограничения, связанные с тем, что Windows не может распознать старые приложения, которые поддерживают высокие значения DPI. Поэтому приложения должны включать манифест или вызывать SetProcessDPIAware (в User32) для объявления о своей поддержке высоких значений DPI. Хотя WPF-приложения обрабатывают этот шаг корректно, приложения, разработанные до появления Windows Vista, не могут воспользоваться ни одним из подходов, и обречены на неидеальное масштабирование растровых изображений. Существуют два возможных решения. При наличии нескольких специфичных приложений, которые поддерживают высокие установки DPI, но не сообщают об этом, эту деталь можно сконфигурировать вручную. Для этого щелкните правой кнопкой мыши на ярлыке, запускающем приложение (в меню Пуск) и выберите в контекстном меню пункт Свойства. На вкладке Совместимость отметьте флажок Отключить масштабирование изображения при высоком разрешении экрана. Однако если придется конфигурировать много приложений, эти действия могут оказаться довольно утомительными. Другое возможное решение заключается в том, чтобы вообще отключить масштабирование растровых изображений. Для этого отметьте флажок Использовать масштабы в стиле Windows ХР в диалоговом окне Выбор масштаба, которое показано на рис. 1.1. Единственное ограничение этого подхода связано с тем, что могут существовать приложения, которые некорректно отображаются (и потому могут даже оказаться неработоспособными) при высоких установках DPI. По умолчанию флажок Использовать масштабы в стиле Windows XP отмечен для значений 120 dpi и менее, но не отмечен для значений свыше 120 dpi. Растровая и векторная графика Когда вы имеете дело с обычными элементами управления, то можете рассчитывать на независимость WPF от разрешения. WPF автоматически заботится о том, чтобы все имело правильные размеры. Однако если в приложении планируется использовать изображения, подобной уверенности быть не может. Например, в традиционных Windows- приложениях для команд панели инструментов применяются крошечные растровые изображения. В приложении WPF такой подход не идеален, потому что растровое изображение может отображать артефакты (размытые), которые будут масштабироваться вверх и вниз согласно системной установке DPI. Вместо этого при проектировании пользовательского интерфейса WPF даже самые мелкие значки обычно реализованы в векторной графике. Векторная графика определена как набор фигур, каждая из которых может быть легко масштабирована до любых размеров. На заметку! Разумеется, отображение векторной графики требует больше времени, чем отрисов- ка базового растрового изображения, но WPF включает набор приемов оптимизации, которые призваны снизить накладные расходы, всегда обеспечивая разумную производительность.
36 Глава 1. Введение в WPF Важность независимости от разрешения переоценить трудно. На первый взгляд это кажется очевидным, элегантным решением старой проблемы (что так и есть). Однако чтобы проектировать полностью масштабируемые интерфейсы, разработчики должны взять на вооружение новый образ мышления. Архитектура WPF Технология WPF использует многоуровневую архитектуру. На вершине ваше приложение взаимодействует с высокоуровневым набором служб, которые полностью написаны на управляемом коде С#. Действительная работа по трансляции объектов .NET в текстуры и треугольники Direct3D происходит "за кулисами", с использованием низкоуровневого неуправляемого компонента по имени milcore.dll. Библиотека milcore.dll реализована в неуправляемом коде потому, что ей требуется тесная интеграция с Direct3D, и вдобавок для нее чрезвычайно важна производительность. На рис. 1.2 показаны уровни, на которых построена работа приложения WPF. PresentationFramework.dll Управляемый API-интерфейс WPF PresentationCore.dll WindowsBase.dll / \ / X milcore.dll WindowsCodecs.dll i т Direct3D User32 Уровень медиа-интеграции Рис. 1.2. Архитектура WPF Ниже описаны ключевые компоненты, присутствующие на рис. 1.2. • PresentationFramework.dll содержит типы WPF верхнего уровня, включая те, что представляют окна, панели и прочие виды элементов управления. Также он реализует высокоуровневые программные абстракции, такие как стили. Большинство классов, которые вы будете использовать, находятся непосредственно в этой сборке. • PresentationCore.dll содержит базовые типы, такие как UIElement и Visual, от которых унаследованы все фигуры и элементы управления. Если вам не нужен полный уровень абстракции окон и элементов управления, можете опуститься ниже, на этот уровень, и продолжать пользоваться преимуществами механизма визуализации WPF. • WindowsBase.dll содержит еще более базовые ингредиенты, которые потенциально могут применяться вне WPF, такие как Dispatcher Object и Dependency Object, поддерживающие механизм свойств зависимости (эта тема будет детально рассмотрена в главе 4).
Глава 1. Введение в WPF 37 • milcore.dll — ядро системы визуализации WPF и фундамент уровня медиа- интеграции (Media Integration Layer — MIL). Его составной механизм транслирует визуальные элементы в треугольники и текстуры, которых ожидает Direct3D. Хотя milcore.dll считается частью WPF, это также важнейший компонент операционных систем Windows Vista и Windows 7. В действительности DWM (Desktop Window Manager — диспетчер окон рабочего стола) использует milcore.dll для отображения рабочего стола. На заметку! C6opKymilcore.dll иногда называют механизмом "управляемой графики". Подобно тому, как общеязыковая исполняющая среда (common language runtime — CLR) управляет жизненным циклом приложения .NET, milcore.dll управляет состоянием дисплея. И так же, как CLR избавляет от забот об освобождении объектов и восстановлению памяти, milcore.dll избавляет от необходимости думать о недействительности и перерисовке окна. Вы просто создаете объекты с содержимым, которое хотите отобразить, a milcore.dll рисует соответствующие части окна, когда оно перемещается, скрывается и раскрывается, сворачивается и восстанавливается, и т.д. • WindowsCodecs.dll —низкоуровневый API-интерфейс, обеспечивающий поддержку изображений (например, обработку, отображение и масштабирование растровых изображений и файлов JPEG). • Direct3D — низкоуровневый API-интерфейс, через который визуализируется вся графика в WPF. • User32 используется для определения того, какое место на экране к какой программе относится. В результате он по-прежнему вовлечен в WPF, но не участвует в визуализации распространенных элементов управления. Наиболее важный факт, который потребуется осознать, состоит в том, что Direct3D визуализирует все рисование в WPF. При этом не важно, установлена на компьютере видеокарта со скромными возможностями или же более мощная, используются базовые элементы управления или рисуется более сложное содержимое, запускается приложение в Windows ХР, Windows Vista или Windows 7. Даже двумерные фигуры и обычный текст трансформируются в треугольники и проходят по трехмерному конвейеру. Какие- либо обращения к GDI+ или User32 отсутствуют. Иерархия классов Читая эту книгу, большую часть времени вы потратите на изучение пространств имен и классов WPF. Но прежде чем начать, полезно взглянуть на общую иерархию классов, которые ведут к базовому набору элементов управления WPF На рис. 1.3 показан базовый обзор некоторых ключевых ветвей иерархии классов. Продвигаясь по главам этой книги, вы будете знакомиться с указанными (и связанными с ними) классами более подробно. В последующих разделах описаны основные классы из этой диаграммы. Многие из них ведут к целым ветвям элементов (таких как фигуры, панели и элементы управления). На заметку! Основные пространства имен WPF начинаются в System.Windows (например, System.Windows, System.Windows .Controls и System.Windows .Media). Единственным исключением являются пространства имен, начинающиеся с System.Windows. Forms, которые относятся к инструментам Windows Forms.
38 Глава 1. Введение в WPF Shape DispatcherObject i DependencyObject i Visual Условные обозначения Абстрактный класс Конкретный класс ж UlElement FrameworkElement I Control Panel ContentControl 4 ItemsControl Рис. 1.3. Фундаментальные классы WPF System. Threading. DispatcherObject Приложения WPF используют знакомую однопоточную модель (single-thread affinity — STA), а это означает, что весь пользовательский интерфейс принадлежит единственному потоку. Взаимодействовать с элементами пользовательского интерфейса из других потоков небезопасно. Чтобы содействовать работе этой модели, каждое WPF-приложение управляется диспетчером, координирующим сообщения (появляющиеся в результате клавиатурного ввода, перемещений курсора мыши и таких процессов платформы, как компоновка). Будучи унаследованным от DispatcherObject, каждый элемент пользовательского интерфейса может удостовериться, выполняется ли код в правильном потоке, и обратиться к диспетчеру, чтобы направить код в поток пользовательского интерфейса. Подробнее о модели многопоточности WPF речь пойдет в главе 31. System.Windows. DependencyObject В WPF центральный путь взаимодействия с экранными элементами пролегает через свойства. На ранней стадии цикла проектирования архитекторы WPF решили создать более мощную модель свойств, которая положена в основу таких средств, как уведомления об изменениях, наследуемые значения по умолчанию и более экономичное хранилище свойств. Конечным результатом стало средство свойств зависимости
Глава 1. Введение в WPF 39 (dependency property), с которым вы ознакомитесь в главе 4. За счет наследования от DependencyObject, классы WPF получают поддержку свойств зависимости. System.Windows.Media.Visual Каждый элемент, появляющийся в WPF, в основе своей является Visual. Класс Visual можно воспринимать как единственный объект рисования, инкапсулирующий в себе инструкции рисования, дополнительные подробности рисования (наподобие отсечения, прозрачности и настроек трансформации) и базовую функциональность (вроде проверки попадания). Класс Visual также обеспечивает связь между управляемыми библиотеками WPF и сборкой milcore.dll, которая визуализирует отображение. Любой класс, унаследованный от Visual, обладает способностью отображаться в окне. Если вы предпочитаете создавать свой пользовательский интерфейс с применением легковесного API-интерфейса, не обладающего высокоуровневыми средствами WPF, то можете программировать непосредственно с использованием объектов Visual, как описано в главе 14. System. Windows. UIElement Класс UIElement добавляет поддержку таких сущностей WPF, как компоновка (layout), ввод (input), фокус (focus) и события (events) — все, что команда разработчиков WPF называет аббревиатурой LIFE. Например, именно здесь определен двухшаговый процесс измерения и организации компоновки, о котором вы узнаете в главе 18. Здесь же щелчки кнопками мыши и нажатия клавиш трансформируются в более удобные события, такие как MouseEnter. Как и со свойствами, WPF реализует расширенную систему передачи событий, именуемую маршрутизируемыми событиями (routed events). В главе 5 будет показано, как она работает. И, наконец, UIElement добавляет поддержку команд (см. главу 9). Sys tern. Windows. FrameworkElemen t Класс FrameworkElement — конечный пункт в центральном дереве наследования WPF Он реализует некоторые члены, которые просто определены в UIElement. Например, UIElement устанавливает фундамент для системы компоновки WPF, но FrameworkElement включает ключевые свойства (вроде HorizontalAlignment и Margin), которые поддерживают его. UIElement также добавляет поддержку привязки данных, анимации и стилей — все они являются центральными средствами. System. Windows. Shapes. Shape От этого класса наследуются базовые фигуры, такие как Rectangle, Polygon, Ellipse, Line и Path. Эти фигуры могут использоваться наряду с более традиционными графическими элементами Windows вроде кнопок и текстовых полей. Построением фигур мы займемся в главе 12. System. Windows. Controls. Control Элемент управления (control) — это элемент, который может взаимодействовать с пользователем. К нему очевидным образом относятся такие классы, как Text Box, Button и ListBox. Класс Control добавляет дополнительные свойства для установки шрифта, а также цветов переднего плана и фона. Но наиболее интересная деталь, которую он предоставляет — это поддержка шаблонов, которая позволяет заменять стандартный внешний вид элемента управления собственным рисованием. Шаблоны элементов управления рассматриваются в главе 17.
40 Глава 1. Введение в WPF На заметку! В программировании с применением Windows Forms любой визуальный компонент в форме называется элементом управления. В WPF это не так. Визуальные единицы называются элементами (element), и только некоторые из них являются элементами управления (те, что могут принимать фокус и взаимодействовать с пользователем). Еще более запутывает эту систему то, что многие элементы определены в пространстве имен System.Windows.Controls, хотя они не унаследованы от System.Windows.Controls.Control и не могут считаться элементами управления. Примером может служить класс Panel. Sys tern. Windows. Controls. ContentControl Это базовый класс для всех элементов управления, которые имеют отдельный фрагмент содержимого. Сюда относится все — от скромной метки Label до окна Window. Наиболее впечатляющая часть этой модели (которая более детально описана в главе 6) заключается в том, что единственный фрагмент содержимого может быть чем угодно — от обычной строки до панели компоновки, содержащей комбинацию других фигур и элементов управления. System. Windows. Controls. ItemsControl Это базовый класс для всех элементов управления, которые отображают коллекцию каких-то единиц информации, вроде ListBox и TreeView. Списочный элемент управления замечательно гибок; например, используя встроенные средства класса ItemsControl, можно трансформировать обычный ListBox в список переключателей, список флажков, упорядоченный набор картинок или комбинацию совершенно разных элементов по своему выбору. Фактически в WPF все меню, панели инструментов и линейки состояния на самом деле являются специализированными списками, и классы, реализующие их, наследуются от ItemsControl. Вы начнете использовать списки в главе 19, когда пойдет речь о привязке данных. Их расширение вы изучите в главе 20, а наиболее специализированные списочные элементы управления — в главе 22. System. Windows. Controls. Panel Это базовый класс для всех контейнеров компоновки — элементов, которые содержат в себе один или более дочерних элементов и упорядочивают их в соответствии с определенными правилами компоновки. Эти контейнеры образуют фундамент системы компоновки WPF, и их использование — ключ к упорядочиванию содержимого наиболее привлекательным и гибким способом. Система компоновки WPF более детально рассматривается в главе 3. WPF4 WPF 4 — относительно новая технология. Частично она входила в несколько выпусков .NET и постепенно совершенствовалась. • WPF 3.0. Первая версия WPF вышла вместе с двумя другими технологиями: Windows Communication Foundation (WCF) и Windows Workflow Foundation (WF). Все вместе это называлось .NET 3.0. • WPF 3.5. ГЪд спустя, вышла новая версия WPF, как часть .NET Framework 3.5. Новые средства WPF в основном были слегка усовершенствованы, включая исправление ошибок и повышение производительности. • WPF 3.5 SP1. Когда вышел пакет обновлений .NET Framework Service Pack 1 (SP1), проектировщики WPF получили возможность добавить некоторые новые средства, подобные сглаженной графике (благодаря построителям текстуры) и изощренному элементу управления DataGrid.
Глава 1. Введение в WPF 41 • WPF 4. В последнем выпуске WPF появилось множество улучшений, включая ценные новые средства, построенные на базе существующей инфраструктуры WPF. Среди некоторых наиболее заметных изменений — улучшенная визуализация текста, более естественная анимация и поддержка средств Windows 7, таких как сенсорные возможности и новая панель задач. Новые средства В этой книге охвачены все концепции WPF, включая самые броские новые средства и базовые принципы, которые остаются неизменными с момента появления этой технологии. Однако если вы — опытный разработчик WPF, заглядывайте во врезки "Что нового?", предлагаемые в начале каждой главы. В них детализируется относительно новый материал, т.е. средства, которые появились в WPF 3.5 SP1 или WF 4. Если такой врезки нет, то, скорее всего, в главе рассматриваются устоявшиеся средства WPF, которые в последнем выпуске не изменились. Приведенный ниже список поможет идентифицировать ряд наиболее заметных изменений, произошедших со времени выхода WPF 3.0, а также отыскать главы, в которых обсуждается каждое из средств. • Новые элементы управления. Семейство элементов WPF продолжает расти. Теперь оно включает профессиональный выглядящий DataGrid (глава 22), стандартные DataPicker и Calendar (глава 6) и встроенный WebBrowser для просмотра HTML-разметки и веб-серфинга (глава 24). Отдельная загрузка также добавляет полезный элемент управления Ribbon (глава 25), который придает приложениям современный вид. • Усовершенствования двухмерной графики. Теперь визуальное представление каждого элемента может быть радикально изменено посредством эффектов в духе PhotoShop — через построители текстур (с использованием вплоть до версии 3 стандарта построителей текстуры). Разработчики, которые желают манипулировать индивидуальными пикселями вручную, могут также генерировать и модифицировать изображения с помощью класса WriteableBitmap. Оба средства рассматриваются в главе 14. • Облегчение анимации. Эти функции позволяют создавать более жизнеподобные анимации, которые прыгают, ускоряются и качаются естественным образом. Полное описание содержится в главе 15. • Диспетчер визуального состояния. Впервые появившийся в Silverlight, диспетчер визуального состояния (см. главу 17) облегчает изменение обложек элементов управления без необходимости понимания их внутреннего устройства и работы. • Windows 7. Новейшая операционная система от Microsoft добавила целый пакет новых средств. WPF включает естественную поддержку улучшенной панели задач, позволяя использовать списки переходов, перекрытия значков, уведомления о ходе работ и панели инструментов с миниатюрами (все это рассматривается в главе 23). При наличии соответствующего оборудования можно использовать поддержку WPF сенсорных возможностей Windows 7 (глава 5), которые позволяют с помощью жестов на сенсорном экране управлять визуальными объектами. • Улучшенная визуализация. В WPF продолжает улучшаться качество отображения за счет преодоления проблем, связанных с моделью рисования, не зависящей от разрешения монитора. В WPF 4 можно использовать округление компоновки, которое выравнивает контейнеры по границам пикселей, гарантируя чистое изображение (см. главу 3). То же самое можно сделать при визуализации текста, гарантируя его четкость даже при самых маленьких размерах (см. главу 6).
42 Глава 1. Введение в WPF • Кэширование растровых изображений. При правильном сценарии рабочую нагрузку процессора можно снижать, кэшируя сложную векторную графику в памяти видеокарты. Эта техника удобна, в частности, в случае использования анимации и описана в главе 16. • XAML 2009. В WPF появилась новая версия стандарта разметки XAML, используемого для объявления пользовательского интерфейса в окне или на странице. В нем добавлен ряд небольших улучшений, но, скорее всего, вы пока не захотите ими пользоваться, потому что стандарт не встроен в компилятор WPF XAML. Подробнее об этой ситуации читайте в главе 2. WPF Toolkit Прежде чем новый элемент управления найдет свое место в библиотеках WPF платформы .NET, он начинает свою жизнь в составе отдельной загрузки инструментального набора WPF Toolkit. Хотя WPF Toolkit не предсказывает будущего направления развития WPF, это замечательное место, где можно найти практичные компоненты и элементы, выходящие за рамки обычных выпусков WPF. Так, например, WPF не включает никаких инструментов построения диаграмм, а в WPF Toolkit вы найдете набор элементов для создания столбчатых, круговых, линейных и прочих диаграмм. В этой книге периодически встречаются ссылки на WPF Toolkit, когда имеет смысл указать на полезную часть функциональности, которая не доступна в ядре исполняющей среды .NET Для загрузки WPF Toolkit, ознакомления с его кодом либо изучения документации обратитесь по адресу http://wpf.codeplex.com. Там же вы найдете ссылки на другие управляемые Microsoft проекты WPF, включая WPF Features (куда входят экспериментальные средства WPF) и средства тестирования WPF Visual Studio 2010 Хотя пользовательские интерфейсы WPF можно строить вручную либо с помощью графического инструмента Expression Blend, большинство разработчиков начинают с Visual Studio и проводят в нем большую часть времени. В этой книге предполагается, что вы пользуетесь Visual Studio, и периодически объясняется, как применять Visual Studio для решения важнейших задач, таких как добавление ресурса, конфигурирование свойств проекта или создание сборки с библиотекой элементов управления. Однако много времени на исследование разнообразных средств времени проектирования тратиться не будет. Вместо этого внимание будет сосредоточено на лежащей в основе разметке и коде, что понадобится для создания профессиональных приложений. На заметку! Возможно, вы уже знаете, как создается проект WPF в Visual Studio, но стоит кратко напомнить. Сначала выберите пункт меню File о New о Project (Файл ^Создатьо Проект) Затем в открывшемся диалоговом окне выберите группу Visual C#c=>Windows (в дереве слева), а в ней — шаблон WPF Application (в списке справа). В главе 24 вы узнаете о более специализированном шаблоне WPF Browser Application. Выбрав каталог, введите имя проекта и щелкните на кнопке ОК. В результате получается базовая структура приложения WPF Поддержка множества целевых платформ В прошлом каждая версия Visual Studio была тесно привязана к определенной версии .NET. Версия Visual Studio 2010 свободна от этого ограничения и позволяет проектировать приложения, ориентированные на любую версию .NET— от 2.0 до 4. Хотя очевидно невозможно создать приложение WPF для .NET 2.0, в версиях .NET 3.0 и 3.5 поддержка WPF имеется. Выбор в качестве целевой платформы .NET 3.0 обеспе-
Глава 1. Введение в WPF 43 чивает наиболее широкую совместимость (т.к. приложения .NET 3.0 могут работать под управлением исполняющих сред .NET 3.0, 3.5 и 4). Выбор в качестве целевой платформы .NET 3.5 или .NET 4 открывает доступ к новейшим средствам WPF, имеющимся в .NET. При создании нового проекта в Visual Studio можно выбирать целевую версию .NET Framework в раскрывающемся списке, который расположен в верхней части диалогового окна New Project (Новый проект) прямо над списком шаблонов проектов (рис. 1.4). New Project Instated Templates л Visual С* Windows Web Office Cloud Reporting SharePoint Sirverlight ::ШШ) ; NET Framework 20 NET Framework ЗЛ NET Framework 35 e! ' <|М1?1ге|п?1|Г|ТПн^,,1> Sort by: Default bplication Visual C* Visual C* Type: Visual C* Windows Presentation Foundation client application ЧН Console Application ^gfj Class Library d WPF Browser Application Visual C* Location: Solution: Solution name: Wpf Application DADes ktop\ Create пел solution Bro, Create directory for solution Add to source control Рис. 1.4. Выбор целевой версии .NET Framework Целевую версию можно изменить в любой момент позже, дважды щелкнув на узле Properties (Свойства) в окне Solution Explorer (Проводник решения) и изменив выбор в списке Target Framework (Целевая платформа). Для обеспечения аккуратной поддержки множества целевых платформ Visual Studio 2010 включает ссылочные сборки для каждой версии .NET. Эти сборки содержат метаданные каждого типа, но ничего из кода, нужного для их реализации. Это значит, что Visual Studio 2010 может использовать ссылочную сборку для настройки средства IntelliSense и проверки ошибок, гарантируя, что вы не сможете использовать элементы управления, классы или члены, которые не доступны в выбранной версии .NET. Эти метаданные также используются для определения того, что должно появиться в окне Properties (Свойства) и браузере объектов (Object Browser), и т.д., гарантируя, что вся IDE-среда будет ограничена выбранной версией .NET Клиентский профиль .NET Как ни странно, доступны два способа выбрать в качестве цели WPF 4. Первый способ — построить приложение, которое требует стандартной установки полной платформы .NET Framework 4. Второй способ — построить приложение, которому требуется .NET Framework 4 Client Profile (Клиентский профиль .NET Framework 4). Клиентский профиль — это подмножество .NET Framework, которое требуется многофункциональным клиентским приложениями вроде WPF Сюда не входят средства серверной стороны, такие как ASP.NET, отладчики, средства разработки, компиляторы кода и унаследованные средства (подобные поддержке баз данных Oracle). Более важно то, что клиент имеет меньший размер, требуя загрузки около 30 Мбайт, в то время как полный комплект распространения .NET Framework занимает около 100 Мбайт.
44 Глава 1. Введение в WPF Естественно, если приложение ориентировано на .NET Framework 4 Client Profile, оно без проблем будет работать под управлением полной версии .NET Framework. Концепция клиентского профиля появилась в .NET 3.5 SP1. Однако в ней по-прежнему присутствуют несколько моментов, которые мешают ей стать стандартом. В .NET 4 были проведены работы по тонкой настройке средств, включаемых в комплект клиентского профиля, предполагая сделать его стандартным выбором для любого приложения. В Visual Studio 2010 большинство проектов автоматически нацелены на .NET Framework 4 Client Profile. (Именно это вы получаете, выбирая .NET Framework 4 в диалоговом окне New Project.) Изменив настройку Target Framework (Целевая платформа) в свойствах проекта, можно увидеть более подробный список, который имеет отдельные опции для полной версии .NET Framework 4 и .NET Framework 4 Client Profile. При выборе целевой версии .NET часто важно учитывать, насколько широко распространены различные исполняющие среды в настоящее время. В идеале пользователи должны иметь возможность запускать приложения, не требуя дополнительного шага по загрузке и установке. Ниже дано несколько советов, которые помогут принять правильное решение. • Windows Vista включает .NET Framework 3.0. • Windows 7 включает .NET Framework 3.5 SP1. • .NET Framework 4 Client Profile является рекомендуемым обновлением (через службу Windows Update) для Windows Vista и Windows 7. Для компьютеров Windows XP оно является необязательным. Визуальный конструктор Visual Studio Несмотря на тот факт, что Visual Studio является важнейшим инструментом для программирования с применением WPF, в предыдущих версиях был существенный пробел в доступных возможностях — они не предлагали графического визуального конструктора для создания пользовательского интерфейса. В результате разработчики были вынуждены писать код XAML вручную либо переключаться между Visual Studio и более ориентированным на дизайн инструментом Expression Blend. В Visual Studio 2010, наконец, этот недостаток был восполнен за счет появления мощного визуального конструктора для создания пользовательских интерфейсов WPF. Однако тот факт, что Visual Studio 2010 позволяет легко перетаскивать окна WPF на поверхность проектирования, не означает, что это нужно делать прямо сейчас или вообще когда-либо. Как будет показано в главе 3, в WPF используется гибкая и тонкая модель компоновки, которая позволяет применять разные стратегии для задания размеров и позиционирования элементов в рамках пользовательского интерфейса. Для получения нужного результата понадобится использовать корректную комбинацию контейнеров компоновки, правильно организовать их и должным образом сконфигурировать их свойства. Visual Studio может помочь в этом, но будет намного легче, если первым делом освоить основы разметки XAML и компоновки WPF Это позволит впоследствии просматривать код разметки, сгенерированный Visual Studio, и при необходимости модифицировать его вручную. Овладев синтаксисом XAML (глава 2) и ознакомившись с семейством контейнеров компоновки WPF (глава 3), вы сможете сами выбирать, каким образом создавать окна. Часть профессиональных разработчиков используют Visual Studio, часть — Expression Blend, есть те, кто пишет код XAML вручную, а есть те, кто применяет комбинацию перечисленных методов с последующим конфигурированием в визуальном конструкторе Visual Studio.
Глава 1. Введение в WPF 45 Резюме В этой главе был представлен начальный обзор WPF и тех возможностей, которые эта платформа предлагает Вы узнали о лежащей в ее основе архитектуре и кратко об основных классах. WPF — это будущее разработок Windows-приложений. Со временем WPF превратится в систему, подобную User32 и GDI/GDI+, к которой будут добавляться новые расширения и высокоуровневые средства. В конечном итоге WPF позволит проектировать приложения, которые было бы невозможно (или, по крайней мере, непрактично) построить средствами Windows Forms. Естественно, WPF несет в себе много революционных изменений. Однако есть несколько ключевых принципов, которые нужно немедленно сформулировать, поскольку они совершенно отличаются от тех, что лежат в основе предшествующих инструментов для построения пользовательского интерфейса Windows, таких как Windows Forms. Ниже перечислены эти принципы. • Аппаратное ускорение. Все рисование WPF выполняется через DirectX, что позволяет этой технологии пользоваться преимущества современных видеокарт. • Независимость от разрешения. Технология WPF настолько гибкая, что может автоматически выполнять масштабирование вверх и вниз, приспосабливаясь к предпочтениям монитора, в зависимости от системных установок DPI. • Отсутствие фиксированного внешнего вида элементов управления. В традиционной разработке для Windows существует огромная пропасть между элементами управления, которые можно подогнать под ваши нужды (они называются самостоятельно рисуемыми), и теми, которые визуализируются операционной системой, и чей внешний вид, по сути, фиксирован. В WPF все, начиная от базового Rectangle и до стандартного Button или более сложного Toolbar, рисуется посредством механизма визуализации и является полностью настраиваемым. По этой причине элементы управления WPF часто называют лишенными внешности — они определяют функциональность элемента управления, но не имеют жестко привязанной внешности. • Декларативный пользовательский интерфейс. В следующей главе мы рассмотрим XAML — стандарт языка разметки, который используется для определения пользовательских интерфейсов WPF Язык XAML позволяет строить окна без кода. Впечатляет то, что XAML не ограничивает фиксированным неизменным пользовательским интерфейсом. Можно применять такие средства, как привязка данных и триггеры, для автоматизации базового поведения пользовательского интерфейса (вроде текстовых полей, обновляющих себя, когда вы перемещаетесь по источнику записи, или меток, которые подсвечиваются при наведении на них курсора мыши) — и все это вообще без написания кода С#. • Рисование на основе объектов. Даже если планируется работать на низком визуальном уровне (вместо высокого уровня элементов), рисовать в терминах пикселей не придется. Вместо этого будут создаваться объекты фигур, a WPF будет поддерживать отображение в наиболее оптимизированной манере. Эти принципы будут демонстрироваться в действии на протяжении всей книги. Но прежде чем двигаться дальше, необходимо изучить еще один дополняющий стандарт. В следующей главе представлен XAML — язык разметки, предназначенный для определения пользовательских интерфейсов WPF
ГЛАВА 2 XAML XAML (Extensible Application Markup Language — расширяемый язык разметки приложений) представляет собой язык разметки, используемый для создания экземпляров объектов .NET. Хотя язык XAML — это технология, которая может быть применима ко многим различным предметным областям, его главное назначение — конструирование пользовательских интерфейсов WPF. Другими словами, документы XAML определяют расположение панелей, кнопок и прочих элементов управления, составляющих окна в приложении WPF. Маловероятно, что вам придется писать код XAML вручную. Вместо этого вы будете пользоваться инструментом, генерирующим необходимый код XAML. Если вы — дизайнер графики, скорее всего, таким инструментом будет программа графического дизайна вроде Expression Blend. Если же вы — разработчик, то наверняка начнете с Visual Studio. Поскольку оба инструмента поддерживают XAML, вы можете создать базовый пользовательский интерфейс в Visual Studio, а затем передать его команде дизайнеров, которые доведут его до совершенства, добавив специальную графику с помощью Expression Blend. Фактически такая способность интегрировать рабочий поток разработчиков и дизайнеров — одна из ключевых причин создания Microsoft языка XAML. В этой главе предлагается детальное введение в XAML. Будет рассмотрено его предназначение, общая архитектура и синтаксис. Поняв основные правила XAML, вы узнаете, что возможно и что невозможно в пользовательском интерфейсе WPF, и как при необходимости провести в нем ручные изменения. Что более важно — за счет исследования дескрипторов в XAML-документе WPF вы можете много узнать об объектной модели, которая положена в основу пользовательских интерфейсов WPF, и подготовиться к углубленному ее изучению. Что нового? В WPF 4 был представлен XAML 2009 — обновленная версия языка XAML, имеющая множество полезных усовершенствований. Однако есть некоторые ограничения- в настоящее время XAML 2009 можно использовать только в несвязанных файлах XAML. Хотя Visual Studio поддерживает и несвязанные, и скомпилированные файлы XAML (как будет показано в этой главе), скомпилированные файлы XAML являются стандартом. Они позволяют не только работать с моделью отделенного кода, давая возможность подключать код с минимальными усилиями, но также гарантируют, что скомпилированное приложение будет иметь меньший размер и загрузится немного быстрее. В связи с этим XAML 2009 не будет использоваться в примерах, рассматриваемых в книге. Тем не менее, вы сможете получить предварительное представление о расширениях XAML 2009 в разделе "XAML 2009". Эта информация подготовит к будущим выпускам WPF, поскольку XAML 2009 претендует на роль нового стандарта (как только в Microsoft найдут время для переписывания, тестирования и оптимизации XAML-компилятора WPF).
Глава 2. XAML 47 Особенности XAML Разработчики давно поняли, что создавать сложные, графически насыщенные приложения намного легче, если отделить графическую часть от лежащего в основе кода. Таким образом, художники могут заниматься графикой, а разработчики — кодом. Обе части могут проектироваться и совершенствоваться по отдельности, без проблем, связанных с множеством версий. Графический интерфейс пользователя до WPF В традиционных технологиях отображения не существовало простого способа отделить графическое содержимое от кода. Ключевая проблема приложений Windows Forms состоит в том, что каждая форма, которую вы создаете, целиком определяется в коде С#. При помещении элементов управления на поверхность проектирования и их конфигурировании Visual Studio молча вносит изменения в код соответствующего класса формы. К сожалению, дизайнеры графики не располагают инструментами, которые могут работать с кодом С#. Вместо этого художники вынуждены создавать и экспортировать свой продукт в растровом формате. Эти растровые изображения затем могут использоваться для оформления окон, кнопок и других элементов управления. Такой подход хорошо работает с простыми интерфейсами, которые мало изменяются с течением времени, но весьма ограничен в других сценариях. К его проблемам можно отнести перечисленные ниже. • Каждый графический элемент (фон, кнопка и т.п.) должен экспортироваться как отдельное растровое изображение. Это ограничивает возможности их комбинирования и применения динамических эффектов, таких как сглаживание, прозрачность и тени. • Значительная часть логики пользовательского интерфейса должна быть встроена в код разработчиком. Сюда относятся размеры кнопок, позиционирование, эффекты от перемещения курсора мыши и анимация. Дизайнер графики не может контролировать эти детали. • Не существует внутренней связи между разными графическими элементами, так что легко создать не соответствующие друг другу наборы изображений. Отслеживание всех этих элементов привносит дополнительную сложность. • Растровые изображения не могут изменяться в размерах без потери качества. По этой причине пользовательский интерфейс на основе растрового изображения зависит от разрешения. Это значит, что он не может быть адаптирован к большим мониторам и дисплеям высокого разрешения, что нарушает основы проектной философии WPF. Если вам когда-либо доводилось проходить через процесс проектирования приложений Windows Forms с использованием специальной графики в командной среде, вы, несомненно, сталкивались с массой разочарований. Даже если интерфейс спроектирован с нуля дизайнером графики, он должен быть воссоздан в коде С#. Обычно дизайнеру графики просто приходится подготавливать макет, который затем нужно мучительно транслировать в работающее приложение. В WPF эта проблема решается с помощью XAML. При проектировании WPF-прило- жения в Visual Studio создаваемое окно не транслируется в код. Вместо этого оно се- риализуется в набор дескрипторов XAML. После запуска приложения эти дескрипторы используются для генерации объектов, составляющих пользовательский интерфейс.
48 Глава 2. XAML На заметку! Важно понимать, что WPF не требует обязательного применения XAML. Нет причин, по которым система Visual Studio не могла бы использовать подход Windows Forms и сразу создавать операторы кода, конструирующие окна WPF. Но в этом случае окно будет "заперто" в среде Visual Studio и доступно только программистам. Другими словами, для WPF не требуется XAML. Однако XAML открывает возможности для кооперации, поскольку другие инструменты проектирования понимают формат XAML. Например, изобретательный дизайнер может использовать такой инструмент, как Expression Design, чтобы настроить графику для приложения WPF, или же инструмент вроде Expression Blend, чтобы построить для него изощренную анимацию. По окончании чтения этой главы имеет смысл ознакомиться с официальным документом от Microsoft, доступным по адресу http://windowsclient.net/wpf/white-papers/ thenewiteration.aspx, в котором предлагается обзор XAML, и объясняются некоторые способы кооперации разработчиков и дизайнеров при построении приложения WPF. Совет. XAML играет ту же роль для приложений Windows, что управляющие дескрипторы для веб- приложений ASP.NET. Отличие состоит в том, что синтаксис дескрипторов ASP.NET задуман похожим на HTML, так что дизайнеры могут создавать веб-страницы, используя обычные приложения для веб-дизайна, такие как FrontPage и Dreamweaver. Как и в WPF, сам код веб-страницы ASP.NET обычно размещается в отдельном файле, облегчая проектирование Разновидности XAML Существует несколько разных способов использования термина XAML. До сих пор он применялся для ссылки на весь язык XAML, предлагающий основанный на XML синтаксис для представления дерева объектов .NET. (Эти объекты могут быть кнопками и текстовыми полями в окне, а также специальным, определенным вами классом. Фактически XAML даже может использоваться на других платформах, чтобы представлять объекты, не имеющие отношения к .NET.) Существует несколько подмножеств XAML. • WPF XAML включает элементы, описывающие содержимое WPF, такое как векторная графика, элементы управления и документы. В настоящее время это наиболее важное применение XAML, и именно это его подмножество будет рассматриваться в настоящей книге. • XPS XAML — часть WPF XAML, определяющая XML-представление форматированных электронных документов. Она опубликована как отдельный стандарт XML Paper Specification (XPS). Вы узнаете о XPS в главе 28. • Silverlight XAML — подмножество WPF XAML, предназначенное для Silverlight- приложений. Silverlight — это межплатформенный браузерный подключаемый модуль, который позволяет создавать расширенное веб-содержимое с двумерной графикой, анимацией, аудио и видео. Дополнительная информация о Silverlight была дана в главе 1. Можно также посетить сайт http://silverlight.net. • WF XAML включает элементы, описывающие содержимое Windows Workflow Foundation (WF). Дополнительная информация о WF доступна на сайте http:// msdn.microsoft.com/ru-ru/netframework/aa663328.aspx. Компиляция XAML Создатели WPF знали, что XAML не только нужен для решения проблемы совместного проектирования, он также должен быть быстрым. И хотя такие основанные на XML
Глава 2. XAML 49 форматы, как XAML, гибки и легко переносимы на другие инструменты и платформы, они не всегда являются наиболее эффективным выбором. XML задуман как непротиворечивый, читабельный и прямолинейный, но не компактный формат В WPF этот недостаток преодолен посредством BAML (Binary Application Markup Language — двоичный язык разметки приложений). BAML — это не что иное, как двоичное представление XAML. Когда вы компилируете приложение WPF в Visual Studio, все файлы XAML преобразуются в код BAML, и этот код BAML затем встраивается в виде ресурса в финальную сборку DLL или ЕХЕ. Язык BAML поддерживает лексемъи а это значит, что длинные фрагменты XAML заменены короткими лексемами. И код BAML не только существенно меньше, но он также оптимизирован, чтобы быстрее интерпретироваться во время выполнения. Большинству разработчиков не приходится беспокоиться о преобразовании XAML в BAML, потому что компилятор это делает "за кулисами". Однако можно использовать XAML без предварительной компиляции. Это может иметь смысл в сценариях, когда часть пользовательского интерфейса должна быть применена прямо во время выполнения (например, извлечена из базы данных в виде блока дескрипторов XAML). В разделе "Загрузка и компиляция XAML' далее в главе будет показано, как это работает. Создание XAML в Visual Studio В этой главе мы рассмотрим детали разметки XAML. Разумеется, при проектировании приложения вручную писать код XAML не придется. Вместо этого с помощью инструмента, подобного Visual Studio, создается нужное окно методом перетаскивания. Потому столь подробное изучение синтаксиса XAML может показаться излишним. Тем не менее, это, безусловно, необходимо. Понимание XAML чрезвычайно важно для проектирования приложений WPF. Это поможет разобраться в ключевых концепциях WPF, таких как присоединенные свойства (настоящая глава), компоновка (глава 3), маршрутизируемые события (глава 4), модель содержимого (глава 6) и т.д. Что более важно — существует целый ряд задач, решение которых возможно только с помощью вручную написанного Kon.a~XAML либо в этом случае оно существенно облегчается. Ниже перечислены примеры таких задач. • Привязка обработчиков событий. Присоединение обработчиков событий в наиболее распространенных местах — например, к событию Click для Button — легко сделать в Visual Studio. Однако, однажды поняв, как события привязываются в XAML, можно создавать более изощренные соединения. Например, можно установить обработчик событий, реагирующий на событие Click каждой кнопки окна. Более подробно эта технология рассматривается в главе 5. • Написание выражений привязки данных. Привязка данных позволяет извлекать данные из объекта и отображать их в привязанном элементе. Чтобы установить это отношение и сконфигурировать его работу, в код разметки XAML понадобится добавить выражение привязки данных. Привязка данных рассматривается в главе 8. • Определение ресурсов. Ресурсы — это объекты, которые определяются в специальном разделе кода XAML, а затем многократно используются в разных местах кода разметки. Ресурсы позволяют централизовать и стандартизировать форматирование и создание невизуальных объектов, таких как шаблоны и анимации. Создание и использование ресурсов будет описано в главе 10. • Определение анимации. Анимация — распространенный ингредиент приложений XAML. Обычно они определяются в виде ресурсов, конструируются с использованием разметки XAML, а затем привязываются к другим элементам управления (либо инициируются в коде). В настоящее время в Visual Studio не предусмотрена поддержка создания анимации во время проектирования. Анимация рассматривается в главе 15. • Определение шаблонов элементов управления. Элементы управления WPF проектируются как лишенные внешнего вида; это значит, что вместо стандартных визуальных представлений
50 Глава 2. XAML можно подставлять собственные. Чтобы сделать это, понадобится создать собственный шаблон элемента управления, который представляет собой не что иное, как блок разметки XAML. Шаблоны элементов управления описаны в главе 17. Большинство разработчиков WPF используют комбинацию приемов, разрабатывая часть пользовательского интерфейса с помощью инструмента проектирования (Visual Studio или Expression Blend), а затем проводя тонкую настройку за счет ручного редактирования кода разметки. В главе 3 рассматриваются контейнеры компоновки, которые удобнее всего использовать для правильного размещения множества элементов управления в окне. Основы XAML Стандарт XAML достаточно очевиден, если понять несколько его основополагающих правил. • Каждый элемент в документе XAML отображается на экземпляр класса .NET. Имя элемента в точности соответствует имени класса. Например, элемент <Button> сообщает WPF, что должен быть создан объект Button. • Как и любой XML-документ, код XAML допускает вложение одного элемента внутрь другого. Как будет показано, XAML предоставляет каждому классу гибкость в принятии решения относительно того, как справиться с такой ситуацией. Однако вложение обычно является способом выразить включение (containment). Другими словами, если вы видите элемент Button внутри элемента Grid, то пользовательский интерфейс, возможно, включает Grid, содержащий внутри себя Button. • Свойства каждого класса можно устанавливать через атрибуты. Тем не менее, в некоторых ситуациях атрибуты не достаточно мощны, чтобы справиться с этой работой. В этих случаях понадобятся вложенные дескрипторы со специальным синтаксисом. Совет. Если вы — полный новичок в XML, то лучше изучить его основы и только затем заняться XAML. Для быстрого ознакомления с XML можно обратиться к бесплатному веб-руководству по адресу http://www.w3schools.com/xml. Прежде чем продолжить, взгляните на следующий простейший документ XAML, представляющий новое пустое окно (как оно создано в Visual Studio). Строки пронумерованы для облегчения ссылок на них. 1 <Window x:Class="WindowsApplicationl.Windowl" 2 xmlns="http://schemas.microsoft.com/winfx/2 00 6/xaml/presentation" 3 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 4 Title="Windowl" Height=00" Width=00"> 5 6 <Grid> 7 </Grid> 8 </Window> Этот документ содержит всего два элемента — элемент верхнего уровня Window, который представляет все окно, и элемент Grid, куда можно поместить свои элементы управления. Хотя можно использовать любой элемент верхнего уровня, приложение WPF полагается только на несколько из них: • Window; • Page (похож на Window, но используется для приложений с возможностями навигации); • Application (определяет ресурсы приложения и начальные установки).
Глава 2. XAML 51 Как и во всех документах XML, может существовать только один элемент верхнего уровня. В предыдущем примере это означает, что закрытие элемента Window дескриптором </Window> завершает документ. Никакое дополнительное содержимое уже не допускается. Если вы посмотрите на открывающий дескриптор элемента Window, то найдете там несколько интересных атрибутов, в том числе имя класса и два пространства имен XML (рассматриваются в последующих разделах). Также вы обнаружите три свойства, показанные ниже: 4 Title="Windowl" Height=00" Width=00"> Каждый атрибут соответствует отдельному свойству в классе Window. В конечном итоге это инструктирует WPF о необходимости создать окно с заголовком Windowl размером 300x300 единиц. На заметку! Как известно из главы 1, в WPF используется относительная система измерения, которая не похожа на то, чего ожидает большинство разработчиков Windows. Вместо того чтобы позволить задавать размеры в физических пикселях, в WPF применяются независимые от устройства единицы, которые могут масштабироваться для заполнения разных разрешений монитора, и определены как 1/96 часть дюйма. Это значит, что окно размером 300x300 единиц из предыдущего примера будет визуализировано в виде окна 300x300 пикселей, если системная установка DPI составляет стандартные 96 dpi. Однако в системах с более высоким значением системного DPI будет использовано больше пикселей. Подробности были даны в главе 1. Пространства имен XAML Ясно, что не достаточно просто указать имя класса. Анализатору XAML также нужно знать пространство имен .NET, где находится этот класс. Например, класс Window может существовать в нескольких пространствах имен — он может ссылаться на класс System.Windows.Window, на класс в компоненте от независимого разработчика или же на класс, определенный в вашем приложении. Чтобы определить, какой именно класс нужен на самом деле, анализатор XAML проверяет пространство имен XML, к которому относится элемент. Вот как это работает. В примере документа, показанном ранее, определено два пространства имен: 2 xmlns="http://schemas.microsoft.com/winfx/2 00 6/xaml/presentation" 3 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" На заметку! Пространства имен объявляются с помощью атрибутов. Эти атрибуты могут помещаться внутрь начального дескриптора любого элемента. Однако согласно принятым соглашениям все пространства имен, которые нужно использовать в документе, должны быть объявлены в самом первом дескрипторе, как это сделано в данном примере Как только пространство имен объявлено, оно может использоваться в любом месте документа. xmlns — это специализированный атрибут в мире XML, который зарезервирован для объявления пространств имен. В показанном выше фрагменте кода разметки объявлены два пространства имен, которые будут присутствовать в каждом создаваемом документе WPF XAML. • http://schemas.microsoft.com/winfx/2006/xaml/presentation — основное пространство имен WFP. Оно охватывает все классы WPF, включая элементы управления, которые применяются для построения пользовательских интерфейсов. В рассматриваемом примере это пространство имен объявлено без префикса
52 Глава 2. XAML пространства имен, поэтому становится пространством имен по умолчанию для всего документа. Другими словами, каждый элемент автоматически помещается в это пространство имен, если только не указано иное. • http://schemas.microsoft.com/winfx/2006/xaml — пространство имен XAML. Оно включает различные служебные свойства XAML, которые позволяют влиять на то, как интерпретируется документ. Данное пространство имен отображается на префикс х. Это значит, что его можно применять, помещая префикс пространства имен перед именем элемента (как в <х:ИмяЭлемента>). Как видите, пространство имен XML не соответствует какому-либо конкретному пространству имен .NET. Существует несколько причин, по которым создатели XML выбрали такое проектное решение. По существующему соглашению пространства имен XML часто имеют форму URI (как и в данном примере). Эти URI выглядя