.NET 4.5下的Pro WPF 4.5：C#中的专业Windows呈现框架

5星 · 超过95%的资源需积分: 13 74 浏览量更新于2024-07-26 1 收藏 39.14MB PDF 举报

"Pro WPF 4.5 in C# Windows Presentation Foundation in .NET 4.5" 《Pro WPF 4.5 in C#》是针对.NET 4.5框架和Visual Studio 2012的专业Windows Presentation Foundation（WPF）开发指南。这本书深入浅出地介绍了WPF技术，旨在帮助开发者利用C#语言创建高质量的Windows操作系统用户体验。WPF通过融合各种来源的丰富内容，充分利用Windows计算机的处理能力，提供了强大的用户界面开发框架。本书首先建立了一个坚实的初级概念基础，以读者已有的C#技能为参照，讲解了从XAML到控件以及数据绑定等基础知识。接着，书中逐步深入讨论高级概念，并通过实践案例展示这些概念，突显出使用WPF可以节省的时间和精力。 - **理解WPF编程基础**：XAML（Extensible Application Markup Language）是WPF的核心，用于声明性地构建UI。书中详细介绍了XAML语法、控件的使用以及数据绑定机制，如何将业务逻辑与视图分离，实现MVVM（Model-View-ViewModel）设计模式。 - **实现实际应用场景**：书中涵盖了导航、本地化和部署的实际应用，让读者能够看到这些功能在实际项目中的运作方式。导航机制允许用户在多个视图间自由切换，本地化支持应用程序在不同语言环境下的运行，而有效的部署策略则确保应用能在目标环境中顺利运行。 - **探索高级用户界面控件**：WPF提供了丰富的UI控件集，包括但不限于DataGrid、TreeView、TabControl等，这些控件支持自定义样式和模板，能实现高度定制的用户界面设计。书中会详细介绍这些控件的用法和特性，以及如何扩展和自定义它们以满足特定需求。 - **管理文档**：在WPF中处理文本布局、打印和文档管理是一个重要的部分。书中有详细章节讲解如何在WPF应用程序中处理文本，包括复杂的文本排版、页面布局，以及支持打印功能。此外，还涉及了文档查看器和编辑器的实现，以满足文档处理的需求。此外，书中还可能涵盖了动画和效果、3D图形、多线程编程、性能优化、资源管理和样式系统等内容。对于希望深入了解并熟练掌握WPF的C#开发者来说，这是一本不可或缺的参考书籍。通过学习，开发者可以提升构建现代、交互性强的桌面应用程序的能力。

Chapter 1 ■ IntroduCIng WpF

The following sections describe the core classes in this diagram. Many of these classes lead to whole

branches of elements (such as shapes, panels, and controls).

n Note The core WPF namespaces begin with System.Windows (for example, System.Windows, System.Windows.

Controls, and System.Windows.Media). The sole exception is namespaces that begin with System.Windows.Forms,

which are part of the Windows Forms toolkit.

System.Threading.DispatcherObject

WPF applications use the familiar single-thread afﬁnity (STA) model, which means the entire user

interface is owned by a single thread. It’s not safe to interact with user interface elements from another

thread. To facilitate this model, each WPF application is governed by a dispatcher that coordinates

messages (which result from keyboard input, mouse movements, and framework processes such as

layout). By deriving from DispatcherObject, every element in your user interface can verify whether code

is running on the correct thread and access the dispatcher to marshal code to the user interface thread.

You’ll learn more about the WPF threading model in Chapter 31.

Figure 1-3. The fundamental classes of WPF

Chapter 1 ■ IntroduCIng WpF

System.Windows.DependencyObject

In WPF, the central way of interacting with onscreen elements is through properties. Early on in the design

cycle, the WPF architects decided to create a more powerful property model that baked in features such as

change notiﬁcation, inherited default values, and more economical property storage. The ultimate result is

the dependency property feature, which you’ll explore in Chapter 4. By deriving from DependencyObject,

WPF classes get support for dependency properties.

System.Windows.Media.Visual

Every element that appears in a WPF window is, at heart, a Visual. You can think of the Visual class as a

single drawing object that encapsulates drawing instructions, additional details about how the drawing

should be performed (such as clipping, opacity, and transformation settings), and basic functionality

(such as hit testing). The Visual class also provides the link between the managed WPF libraries and the

milcore.dll that renders your display. Any class that derives from Visual has the ability to be displayed on a

window. If you prefer to create your user interface using a lightweight API that doesn’t have the higher-

level framework features of WPF, you can program directly with Visual objects, as described in Chapter 14.

System.Windows.UIElement

UIElement adds support for WPF essentials such as layout, input, focus, and events (which the WPF team

refers to by the acronym LIFE). For example, it’s here that the two-step measure and arrange layout process

is deﬁned, which you’ll learn about in Chapter 18. It’s also here that raw mouse clicks and key presses are

transformed to more useful events such as MouseEnter. As with properties, WPF implements an enhanced

event-passing system called routed events. You’ll learn how it works in Chapter 5. Finally, UIElement adds

supports for commands (Chapter 9).

System.Windows.FrameworkElement

FrameworkElement is the ﬁnal stop in the core WPF inheritance tree. It implements some of the members

that are merely deﬁned by UIElement. For example, UIElement sets the foundation for the WPF layout

system, but FrameworkElement includes the key properties (such as HorizontalAlignment and Margin)

that support it. UIElement also adds support for data binding, animation, and styles, all of which are core

features.

System.Windows.Shapes.Shape

Basic shapes classes, such as Rectangle, Polygon, Ellipse, Line, and Path, derive from this class. These

shapes can be used alongside more traditional Windows widgets such as buttons and text boxes. You’ll

start building shapes in Chapter 12.

System.Windows.Controls.Control

A control is an element that can interact with the user. It obviously includes classes such as TextBox,

Button, and ListBox. The Control class adds additional properties for setting the font and the foreground

and background colors. But the most interesting detail it provides is template support, which allows you to

Chapter 1 ■ IntroduCIng WpF

replace the standard appearance of a control with your own stylish drawing. You’ll learn about control

templates in Chapter 17.

n Note In Windows Forms programming, every visual item in a form is referred to as a control. In WPF, this isn’t

the case. Visual items are called elements, and only some elements are actually controls (those that can receive

focus and interact with the user). To make this system even more confusing, many elements are deﬁned in the

System.Windows.Controls namespace, even though they don’t derive from System.Windows.Controls.Control and

aren’t considered controls. One example is the Panel class.

System.Windows.Controls.ContentControl

This is the base class for all controls that have a single piece of content. This includes everything from the

humble Label to the Window. The most impressive part of this model (which is described in more detail in

Chapter 6) is the fact that this single piece of content can be anything from an ordinary string to a layout

panel with a combination of other shapes and controls.

System.Windows.Controls.ItemsControl

This is the base class for all controls that show a collection of items, such as the ListBox and TreeView. List

controls are remarkably ﬂexible—for example, using the features that are built into the ItemsControl class,

you can transform the lowly ListBox into a list of radio buttons, a list of check boxes, a tiled display of

images, or a combination of completely different elements that you’ve chosen. In fact, in WPF, menus,

toolbars, and status bars are actually specialized lists, and the classes that implement them all derive from

ItemsControl. You’ll start using lists in Chapter 19 when you consider data binding. You’ll learn to enhance

them in Chapter 20, and you’ll consider the most specialized list controls in Chapter 22.

System.Windows.Controls.Panel

This is the base class for all layout containers—elements that can contain one or more children and

arrange them according to speciﬁc layout rules. These containers are the foundation of the WPF layout

system, and using them is the key to arranging your content in the most attractive, ﬂexible way possible.

Chapter 3 explores the WPF layout system in more detail.

WPF 4.5

WPF is a mature technology. It’s been part of several releases of .NET, with steady enhancements along the

way:

• WPF 3.0: The ﬁrst version of WPF was released with two other new technologies:

Windows Communication Foundation (WCF) and Windows Workﬂow Foundation

(WF). Together, these three technologies were called the .NET Framework 3.0.

• WPF 3.5: A year later, a new version of WPF was released as part of the .NET

Framework 3.5. The new features in WPF are mostly minor reﬁnements, including

bug ﬁxes and performance improvements.

Chapter 1 ■ IntroduCIng WpF

• WPF 3.5 SP1: When the .NET Framework Service Pack 1 (SP1) was released, the

designers of WPF had a chance to slip in a few new features, such as slick graphical

effects (courtesy of pixel shaders) and the sophisticated DataGrid control.

• WPF 4: This release added a number of reﬁnements, including better text rendering,

more natural animation, and support for multitouch.

• WPF 4.5: The latest version of WPF has the fewest changes yet, which reﬂects its

status as a mature technology. Along with the usual bug ﬁxes and performance

tweaks, WPF 4.5 adds a number of reﬁnements to that data binding system,

including improvements to data binding expressions, virtualization, support for the

INotifyDataError interface, and data view synchronization. You’ll see these new

features in Chapter 8, Chapter 19, and Chapter 22.

The WPF Toolkit

Before a new control makes its way into the WPF libraries of the .NET platform, it often begins in a

separate Microsoft download known as the WPF Toolkit. But the WPF Toolkit isn’t just a place to preview

the future direction of WPF—it’s also a great source of practical components and controls that are made

available outside the normal WPF release cycle. For example, WPF doesn’t include any sort of charting

tools, but the WPF Toolkit includes a set of controls for creating bar, pie, bubble, scatter, and line graphs.

This book occasionally references the WPF Toolkit to point out a useful piece of functionality that’s not

available in the core .NET runtime. To download the WPF Toolkit, review its code, or read its

documentation, surf to http://wpf.codeplex.com. There, you’ll also ﬁnd links to other Microsoft-managed

WPF projects, including WPF Futures (which provides more experimental WPF features) and WPF testing

tools.

Visual Studio 2012

Although you can craft WPF user interfaces by hand or using the graphic-design-oriented tool Expression

Blend, most developers will start in Visual Studio and spend most (or all) of their time there. This book

assumes you’re using Visual Studio and occasionally explains how to use the Visual Studio interface to

perform an important task, such as adding a resource, conﬁguring project properties, or creating a control

library assembly. However, you won’t spend much time exploring Visual Studio’s design-time frills. Instead,

you’ll focus on the underlying markup and code you need to create professional applications.

n Note You probably already know how to create a WPF project in Visual Studio, but here’s a quick recap. First,

select File  New  TRA Project. Then, pick the Visual C#  Windows group (in the tree on the left), and choose the

WPF Application template (in the list on the right). You’ll learn about the more specialized WPF Browser Application

template in Chapter 24. After you pick a directory, enter a project name, and click OK, you’ll end up with the basic

skeleton of a WPF application.

Chapter 1 ■ IntroduCIng WpF

Multitargeting

In the past, each version of Visual Studio was tightly coupled to a speciﬁc version of .NET. Visual Studio

2012 doesn’t have this restriction—it allows you to design an application that targets any version of .NET

from 2.0 to 4.5.

Although it’s obviously not possible to create a WPF application with .NET 2.0, all later versions have

WPF support. You may choose to target an older version, such as .NET 3.5 or .NET 4 to get the broadest

possible compatibility. For example, a .NET 3.5 application can run on the .NET 3.5, 4, and 4.5 runtimes.

Or, you may choose to target .NET 4.5 to get access to newer features in WPF or in the .NET platform.

However, if you need to support legacy Windows XP computers, you can’t target a version part of .NET 4,

because this is the last .NET release that supports Windows XP.

When you create a new project in Visual Studio, you can choose the version of the .NET Framework

that you’re targeting from a drop-down list at the top of the New Project dialog box, just above the list of

project templates (see Figure 1-4).

Figure 1-4. Choosing the target version of the .NET Framework

You can also change the version you’re targeting at any point afterward by double-clicking the

Properties node in the Solution Explorer and changing the selection in the Target Framework list.

To provide accurate multitargeting, Visual Studio includes reference assemblies for each version of .

NET. These assemblies include the metadata of every type but none of the code that’s required to

implement it. That means Visual Studio can use the reference assembly to tailor its IntelliSense and error

checking, ensuring that you aren’t able to use controls, classes, or members that aren’t available in the

version of .NET that you’re targeting. It also uses this metadata to determine what controls should appear

in the Toolbox, what members should appear in the Properties window and Object Browser, and so on,

ensuring that the entire IDE is limited to the version you’ve chosen.

剩余1094页未读，继续阅读

bloodelf02

粉丝: 1
资源: 1

.NET 4.5下的Pro WPF 4.5：C#中的专业Windows呈现框架

Pro WPF 4.5 in C#: Windows Presentation Foundation in .NET 4.5

Pro WPF 4.5 in C#_code

WPF编程宝典(Pro WPF in C# 2008)(中文、英文、源代码)

Pro WPF 4.5 in C# WPF 编程宝典 2012和.NET4.5 第四版

Pro WPF 4.5 in C#

Pro WPF 4.5 In C# (WPF编程宝典英文原版)

Pro WPF 4.5 in C#(4th) 无水印pdf

Pro WPF 4.5 in C# （Pro WPF系列第四版 英文书及其源代码）

Pro WPF 4.5 in C# (4th Edition).pdf

Pro WPF in C# 2010_Windows Presentation Foundation in .NET 4

最新资源

Pro WPF 4.5 in C# （Pro WPF系列第四版英文书及其源代码）