Microsoft Prism 4 模块化MVVM应用开发实战

下载需积分: 9 | PDF格式 | 9.2MB | 更新于2024-07-25 | 36 浏览量 | 举报

"Microsoft Prism 4 开发指南" 微软的Prism框架是专为构建模块化、可维护且遵循Model-View-ViewModel (MVVM)设计模式的Windows Presentation Foundation (WPF)和Microsoft Silverlight应用程序而设计的。这本书，"Developer's Guide to Microsoft Prism 4"，由Bob Brumfield、Geoff Cox、David Hill、Brian Noyes、Michael Puleio和Karl Shiffllett合著，提供了关于如何有效利用Prism框架的深入指导。 Prism 4的核心特性包括： 1. **模块化**：Prism提供了一种机制，允许开发者将大型应用程序分解为更小、独立的模块，每个模块都可以单独开发、测试和部署。这有助于提高代码的可维护性和可扩展性。 2. **MVVM模式**：Model-View-ViewModel是一种设计模式，它鼓励开发者分离用户界面的视图部分与业务逻辑和数据模型。在Prism中，MVVM模式使得UI和逻辑的解耦更加容易，有利于测试和重用代码。 3. **依赖注入**：Prism支持依赖注入（DI），这是一种编程技术，允许对象在运行时动态地获取它们的依赖项。这增强了代码的灵活性和可测试性，减少了硬编码的依赖关系。 4. **事件总线**：Prism提供了一个事件总线，允许模块之间进行通信，即使它们在运行时没有直接的引用关系。这对于实现松耦合和组件间的协调非常有用。 5. **指挥者模式**：指挥者模式是一种设计模式，用于协调多个组件之间的交互。在Prism中，指挥者可以帮助管理复杂的视图模型之间的交互，确保应用程序的行为正确无误。 6. **Unity应用程序容器**：Prism通常与Unity容器一起使用，这是一个轻量级的依赖注入容器，可以管理对象的生命周期和组装。 7. **导航服务**：Prism提供了导航服务，简化了在不同视图和视图模型间跳转的过程，支持深链接和回退功能。 8. **命令**：Prism支持命令模式，使得视图能够绑定到业务逻辑，而无需直接引用视图模型，从而保持数据绑定的干净和简洁。通过这本书，开发者可以学习如何有效地利用Prism框架来构建企业级的应用程序，提高开发效率和软件质量。作者们分享了他们的专业知识和实践经验，以帮助读者理解并掌握Prism 4中的关键概念和技术。注意，由于原始内容中包含的信息有限，以上是对Prism 4框架及其开发指南的一般介绍。在实际使用中，开发者应深入阅读本书，以便更全面地了解Prism框架的详细用法和最佳实践。

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

Do w n loa d fro m Wo w ! eB o o k < w ww. w o web o o k.c o m>

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

cooaa

粉丝: 3
资源: 4

Microsoft Prism 4 模块化MVVM应用开发实战

微软Prism4开发指南

Microsoft Prism 4开发指南：构建模块化MVVM应用

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

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

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

Microsoft Prism开发者指南：探索模块化应用开发与MVVM模式

Prism 4视图切换应用开发实践指南

Microsoft PRISM

Developer's Guide to Microsoft Prism 4

Prism4中文文档

最新资源