C# 4.5深度探索：专业WPF 4.5开发指南

需积分: 9 21 浏览量更新于2024-07-23 收藏 12.93MB PDF 举报

"《Pro WPF 4.5 in C# 4th Edition》是一本深度剖析WPF技术的专业开发者指南，专为熟悉.NET平台、C#语言以及Visual Studio开发环境的程序员设计。尽管书中并未强制要求读者具备WPF先前版本的经验，但针对有经验的WPF开发者，每章的“新功能亮点”将突出介绍新特性。本书旨在提供全面、权威的WPF实战教程，内容充实，注重实例讲解，让读者在专业环境中掌握WPF的精髓。首先，作者从基础概念入手，利用读者已有的C#技能作为依托，帮助构建坚实的理论基础。然后，逐步深入探讨高级概念，并通过实践操作演示，强调WPF能带来的时间和效率提升。在阅读过程中，读者将学习到WPF编程的基本要素，如XAML（可扩展应用程序标记语言）的运用，以及控件和数据流的管理。此外，书中的章节还将涵盖如何设计现实场景的应用，涉及导航、本地化和部署等实用技巧。对于WPF提供的高级用户界面控件，无论是定制布局还是实现复杂交互，都有详尽的指导。不仅如此，本书还将教授如何在WPF内处理文档操作，包括文本布局、打印以及文档管理，确保开发者能够充分利用WPF的强大功能来创建出色的用户体验。《Pro WPF 4.5 in C# 4th Edition》是任何希望在Windows操作系统上开发高质量应用的开发者的必备参考书籍，无论你是初学者还是经验丰富的开发者，都能从中获益匪浅。"

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页未读，继续阅读

xzp_ater

粉丝: 0
资源: 7

C# 4.5深度探索：专业WPF 4.5开发指南

WPF编程宝典：使用C# 2012和.NET 4.5（第4版），完整扫描版

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

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

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

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

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

C# 4版详解Pro WPF 4.5高效开发

精通WPF 4.5：C#版第4版实战指南

精通WPF 4.5：C#实战指南，打造卓越Windows应用

C# 4.5深度探索：WPF 4.5高级开发指南

最新资源

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