深入理解WPF：C# 4.5版实战指南

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

"Pro WPF C# 4.5" 《Pro WPF C# 4.5》是一本针对Windows Presentation Foundation (WPF) 框架的深入指南，旨在帮助开发者充分利用WPF来构建高质量、丰富的用户体验应用。该书特别适合具有C#编程背景的读者，通过易于理解的方式介绍WPF的核心概念，并逐步引导读者掌握高级技术。在书中，作者首先从基础入手，讲解WPF编程的基本原理，包括XAML语言，这是WPF界面设计的关键。XAML允许开发者以声明式方式定义用户界面，从而简化UI的设计和维护。此外，书中还会详细介绍控件的使用，如常见的按钮、文本框等，以及数据绑定的概念，使UI与业务逻辑之间的交互变得更加直观和高效。接着，书中的内容扩展到实际应用场景，探讨了导航、本地化和部署等方面。导航系统使得用户可以在应用的不同视图间流畅切换，本地化支持开发多语言应用，而部署策略则涵盖了如何将应用安全、有效地分发给用户。书中深入讨论了WPF提供的高级用户界面控件，这些控件能实现更为复杂的功能，比如数据网格、图表和媒体播放等，为用户带来更丰富、动态的体验。同时，还涵盖了文档管理，包括文本布局、打印支持和文档处理，使得在WPF应用中处理文档变得简单易行。此外，《Pro WPF C# 4.5》还可能涉及到了动画和可视化效果，让开发者能够创建出吸引人的视觉体验；以及资源和模板，通过复用和定制，提高代码的可维护性和可扩展性。书中的每个主题都会通过实例进行演示，让读者能够亲自动手实践，深刻理解并掌握WPF的强大功能。这本书不仅适合初学者快速上手WPF，也对有经验的开发者提供了深入了解和提升技能的宝贵资源。通过学习，读者将能够利用C#和WPF 4.5开发出专业级的桌面应用程序，提升用户体验，充分发挥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页未读，继续阅读

DelphiBoy2003

粉丝: 9
资源: 53

深入理解WPF：C# 4.5版实战指南

C# 4.5版Pro WPF 4.5权威指南：深度解析与实战应用

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

C#深度探索：Pro WPF 4.5实战指南

Pro WPF 4.5 in C#

Pro WPF 4.5 in C#_code

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

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

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

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

Pro WPF 4.5 in C#(第四版)

最新资源

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