使用WPF和Silverlight构建模块化MVVM应用：Microsoft Prism 4开发者指南

需积分: 10 90 浏览量更新于2024-07-22 收藏 3.46MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Prism 4 Building Modular MVVM Applications with WPF" 《Prism 4 Building Modular MVVM Applications with Windows Presentation Foundation and Microsoft Silverlight》是微软出版社出版的一本开发者指南，专注于使用WPF（Windows Presentation Foundation）和Silverlight构建模块化的MVVM（Model-View-ViewModel）应用程序。该书由Bob Brumfield、Geoff Cox、David Hill、Brian Noyes、Michael Puleio和Karl Shifflitt共同撰写，涵盖了Prism框架的详细内容，旨在帮助开发者更高效地构建可维护和可扩展的UI应用程序。 MVVM模式是软件开发中的一种设计模式，特别是在WPF和Silverlight等UI技术中广泛使用。它将用户界面（View）、业务逻辑（ViewModel）和数据模型（Model）分离开来，提高了代码的可测试性和可维护性。Prism框架是微软针对MVVM模式提供的一套工具和最佳实践集合，特别适合大型、复杂的应用程序开发，它提供了模块化、依赖注入、事件通信、命令绑定等核心功能。本书的内容可能包括以下几个方面： 1. **模块化**：Prism支持将应用程序划分为多个独立的模块，每个模块都有自己的功能和逻辑，可以单独开发、测试和部署。这使得应用程序更容易扩展和维护。 2. **依赖注入**：Prism利用IoC（Inversion of Control）容器，如Unity或Autofac，实现依赖注入，帮助解耦组件，提高代码的灵活性和可测试性。 3. **ViewModel和Model**：书中会详细解释如何创建和使用ViewModel，它是View和Model之间的桥梁，负责处理View的交互逻辑，并与Model进行数据交换。 4. **命令绑定**：Prism提供了命令机制，允许在ViewModel中定义命令，然后在View中通过数据绑定进行调用，使得UI操作和业务逻辑分离。 5. **事件通信**：Prism中的EventAggregator服务允许不同模块之间通过事件进行通信，而无需直接引用对方，增强了模块间的解耦。 6. **导航服务**：对于WPF和Silverlight应用，Prism提供了导航服务，用于管理页面间的跳转和参数传递。 7. **复合应用**：Prism支持构建复合应用，即由多个模块组合而成的应用，每个模块都可以独立工作，也可以协同完成更复杂的任务。 8. **最佳实践**：书中还会涵盖一系列的最佳实践和设计原则，帮助开发者遵循良好的架构和编码规范。《Prism 4 Building Modular MVVM Applications with WPF》是一本深入探讨如何使用Prism框架和MVVM模式构建高质量WPF和Silverlight应用的专业书籍，对于想要提升UI开发技能和掌握现代UI架构的开发者来说，是一份宝贵的参考资料。

资源详情

资源推荐

What comes after “Hello, World?”

WPF and Silverlight developers are blessed with an abundance of excellent books,

videos, and online articles from which to learn how to build a single screen application.

These resources teach data binding, dependency properties, resources, styles, effects,

control templating, and many other fundamentals of XAML platform programming.

There’s no lack of tutorials on Model-View-ViewModel (MVVM), the justly popular and

predominant pattern for structuring an individual screen. But they stop short of the guid-

ance you need to deliver a non-trivial application in full.

Your ﬁrst screen goes well. You add a second screen and a third. Because you started

your solution with the built-in “Navigation Application Template,” adding new screens

feels like hanging shirts on a closet rod. You are on a roll. Until the harsh reality of real

application requirements sets in.

As it happens, your application has 30 screens not three. There’s no room on that

closet rod for 30 screens. Some screens are modal pop-ups; you don’t navigate to a pop-

up. Screens become interdependent such that user activity in one screen triggers changes

that propagate throughout the UI. Some screens are optional; others are visible only to

authorized users. Some screens are permanent, while other screens can be opened and

closed at will. You discover that navigating back to a previously displayed screen creates

a new instance. That’s not what you expected and, to your horror, the prior instance is

gone along with the user’s unsaved changes.

You realize that the out-of-the-box navigation is useless to you. You are resigned to

ripping it out and starting over. You consider building your own UI framework, but decide

to survey the scene ﬁrst. Surely someone has been down this road before. Surely someone

has published guidance and code to cope with the scale, variety, and complexity of your

real world application.

Someone has. The Microsoft Prism Library, code samples, and the book that you’re

reading now are the culmination of a ﬁve year quest to consolidate the best advice and

techniques from experts and practitioners in the ﬁeld.

Prism covers all of the scenarios just mentioned and many more. You’ll ﬁnd guidance

and supporting code for:

•

Partitioning the application into modules, those semi-autonomous islands of

functionality that should be developed and maintained independently.

Foreword

xvi

•

Mechanisms for loading modules asynchronously or on-demand so that applications

start quickly.

•

A publish/subscribe apparatus, the event aggregator, for passing messages among

components that cannot and should not connect directly.

•

Dynamically composing a complex screen, such as a dashboard, from several simpler

views.

•

Creating pages using View-First, ViewModel-First, or a controller that makes them

and coordinates them.

•

Initializing views with parameters or context information as when launching an

editor that targets a selected customer.

•

Guidelines and examples of automated tests for views and view models that

depend upon asynchronous data sources.

Many developers will see in Prism an all-in-one solution from a single trusted source.

They have neither the time nor inclination to scrutinize each component, compare it with

competitors, and assemble a custom framework from a buffet of alternatives. They fear

the “Franken-framework” of mismatched parts from multiple vendors. For this audience,

Prism is a safe and reliable choice. I don’t know of a solution as comprehensive, well

documented, or well supported. The design is sound. The code is solid and tested. Great

applications are built exclusively with Prism and yours can be one of them.

Other developers look at Prism a little differently. They see Prism as a compendium

of patterns and strategies for building WPF and Silverlight UIs. The shipped software is a

confederation of optional components. They might embrace Prism modularity but prefer

someone else’s alternative to DelegateCommands. They could choose a third party injec-

tion container instead of MEF or Unity. They might use a region only in the shell or not

use regions at all. For this audience, Prism is a source of inspiration and advice. It’s a

storehouse of code to use, ignore, or replace as they see ﬁt.

One of Prism’s great and hard won achievements is that it supports both perspectives

equally. It’s a coherent framework of cooperating components that work seamlessly to-

gether. Yet each part stands on its own, ready to collaborate, without depending on any

of the others.

Whether you adopt it whole or in part, I urge you to read this book, study the Quick-

Starts, and explore the reference implementations. That’s the best way to master Prism

itself. Better still, you’ll become a more capable programmer, equipped to anticipate real-

world UI architectural challenges and solve them effectively.

Ward Bell

VP Technology, IdeaBlade (www.ideablade.com)

Silverlight MVP

xvii

Foreword

Building WPF and Silverlight applications can be challenging, especially for those new to

the technology. Building clean, maintainable, extensible, testable, loosely coupled ones—

with no idea where to start—is close to impossible. In late 2007, I was privileged to get a

call from Glenn Block at Microsoft asking if I was interested in working with the Micro-

soft patterns & practices team on a project that would become the ﬁrst release of Prism,

which was released as the Composite Application Guidance for WPF in June 2008.

I had been working with WPF on complex customer applications, trying to ﬁgure out

the best practices and patterns on my own. This was a fantastic opportunity to provide

some guidance and feedback to the team on what mattered, what worked, and what

didn’t, in real customer apps that I had worked on. I had worked with various patterns &

practices teams before as an external advisor, but this was my ﬁrst opportunity to come

in as a consultant and participate as an integral part of the team.

It turned out to be a wonderful experience for me. The team included some of the

most intelligent, creative, and fun individuals I have had a chance to work with in this in-

dustry. The maturity of the team’s development process, the effort that they put into

collecting community input and keeping the community involved throughout the devel-

opment process, and their collective design and coding prowess and professionalism

made it clear from the start that the right people were working on guiding the .NET de-

velopment community on the right way to build apps. I learned a ton in the process and

hopefully contributed something that helped make Prism a better product. So, naturally

I was delighted when I got the chance to work closely with the team again on the release

of Prism 4.

Prism 4 offers many things to many people. One of the biggest misconceptions is that

because it offers so much, it is too big or too complicated for smaller apps. One of the

early design goals of Prism was to keep the concerns of Prism separated in the same way

Prism helps you separate your own application’s concerns in the presentation layer. I think

the team did a great job of doing that, and you can easily use just commands, or just

events, or just modularity, or just UI composition or some combination of the above in

ways that are minimally intrusive to the rest of your application code. Add to that the new

Model-View-ViewModel (MVVM) pattern guidance, Managed Extensibility Framework

(MEF) integration, and navigation functionality of Prism 4, and you have a great set of

tools in a toolkit that can help you develop apps of any size.

xviii

If you are writing a small app, there are some great tools and techniques in here that

will help you to keep your app from becoming a maintenance liability. If you are develop-

ing a large application with a complex UI, you need something like Prism 4 to keep you

from being overwhelmed by the complexity and the volume of code that can result from

not basing your app on well-deﬁned design patterns and thoroughly tested code to help

you implement those patterns.

This book is another new feature of Prism 4. Previous releases provided great docu-

mentation in a standard Help format, consisting of many short topics with links to related

topics. And while that format is essential when you are writing code and need to look up

little bits and pieces to keep you moving forward, there was a very important phase of

just getting up to speed on Prism and learning the concepts that was being neglected. You

couldn’t read a book, end-to-end, or chapter by chapter to learn the concepts and see

some code to make those concepts clear, because no such book existed (much as I tried

to ﬁnd the time to write that book myself).

The structure of a good book on a programming technology is inherently different

from good help topics. This book is structured so that you can read it from cover to

cover or just refer to the topics that interest you, without having to be at your computer

as you do so. To supplement the book, the help documentation online has additional

material, including hands-on labs and advanced information about the reference imple-

mentations and QuickStarts. Because the book is available in print and e-book form, you

can take it with you on a plane or to the beach, so that when you do sit down to write

your Prism code, you are immediately productive and past the “What is it and how do I

use it” phase. You can then refer to the online help, hands-on labs, QuickStart topics, and

so on when you are at your computer and using Visual Studio.

Additionally, with this book you get the collective knowledge of the entire team, not

just the perspective of a single or small group of authors. All of the Prism developers and

designers collaborated and contributed to the content you will ﬁnd in this book. If one

person wrote a portion, several others reviewed, commented, and improved it. However,

you are primarily getting the content from the developers who wrote the features, which

is a rare opportunity. Customers often ask me: “Where is the best place to start learning

about Prism, and how can I use it?” In the past, I had to point them to a fragmented

collection of articles, podcasts, and blog posts. Now I have a simple and easy answer, and

I can point them one place – right here to this book.

Brian Noyes

Chief Architect, IDesign Inc. (www.idesign.net)

Silverlight MVP

Introduction1

Prism provides guidance designed to help you more easily design and build rich, ﬂexible,

and easy-to-maintain Windows Presentation Foundation (WPF) desktop applications,

Rich Internet Applications (RIAs) built with the Microsoft

Silverlight

browser plug-in,

and Windows Phone 7 applications. Prism uses design patterns that embody important

architectural design principles, such as separation of concerns and loose coupling. These

patterns help you to design and build applications by using loosely coupled components

that can evolve independently but that can be easily and seamlessly integrated into the

overall application. These types of applications are known as composite applications.

Note: Prism was the code name for the guidance formally known as the Composite

Application Guidance for WPF and Silverlight. For brevity and conciseness, and due to

customer demand, this guidance is now referred to simply as Prism.

Prism is intended for software developers who are building WPF or Silverlight appli-

cations that typically feature multiple screens, rich user interaction, and data visualization,

and that embody signiﬁcant presentation and business logic. These applications typically

interact with multiple back-end systems and services and, using a layered architecture,

may be physically deployed across multiple tiers. It is expected that the applications will

evolve signiﬁcantly over their lifetimes in response to new requirements and business

opportunities. In short, these applications are built to last and built for change. Applica-

tions that do not demand these characteristics may not beneﬁt from using Prism.

Prism includes reference implementations, QuickStarts, reusable library code (the

Prism Library), and extensive documentation. This version of Prism targets the Microsoft

.NET Framework version 4 and Silverlight version 4, and includes new guidance related to

the Model-View-ViewModel (MVVM) pattern, navigation, and the Managed Extensibility

Framework (MEF). Because Prism is built on the .NET Framework 4 (which includes WPF)

and Silverlight 4, familiarity with these technologies is useful for evaluating and adopting

Prism.

It should be noted that, while Prism is not difﬁcult to learn, developers must be ready

and willing to embrace patterns and practices that may be new to them. Management

understanding and commitment is crucial, and the project deadline must accommodate

an investment of time up front for learning these patterns and practices.

剩余279页未读，继续阅读

lsb0733

粉丝: 1
资源: 54

使用WPF和Silverlight构建模块化MVVM应用：Microsoft Prism 4开发者指南

基于Prism框架的MVVM设计模式的WPF实例代码

WPF Prism MVVM弹窗及国际化小示例

WPF MVVM+Prism+MaterialDesign+Sqlite，实现永久性本地存储笔记本

prism7.1.0.431_wpf_官方中文文档

wpf+mvvm+prism

wpf mvvm prism 视频教程

wpf mvvm prism

还能再推荐一些mvvm新手容易入门的wpf例程吗

wpf mvvm框架对比

详解wpf prism mvvm中的ViewModels代码

详解wpf prism mvvm中的ViewModels完整代码

详解wpf prism mvvm中的ViewModels 命令代码

WPF 的prism框架写MVVM绑定的属性太麻烦了，有简单的写属性的方式吗

wpf mvvm框架源码

wpf mvvm开源框架

wpf mvvm框架推荐

wpf mvvm 的样列程序

wpf prism onnavigatedto

.net的MVVM、Prism框架

wpf mvvm 基于 prism 包含model的示例

最新资源