Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Essential Windows Workflow Foundation

3.8 out of 5 stars 23 customer reviews
ISBN-13: 978-0321399830
ISBN-10: 0321399838
Why is ISBN important?
This bar-code number lets you verify that you're getting exactly the right version or edition of a book. The 13-digit and 10-digit formats both work.
Scan an ISBN with your phone
Use the Amazon App to scan ISBNs and compare prices.
Have one to sell? Sell on Amazon
Buy used
Condition: Used: Very Good
Comment: qualifies for free prime shipping. may contain light highlighting, underlining, or writing. may also contain light wear from use.
Access codes and supplements are not guaranteed with used items.
28 Used from $0.01
FREE Shipping on orders over $25.
More Buying Choices
10 New from $4.68 28 Used from $0.01
Free Two-Day Shipping for College Students with Prime Student Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student

Best Books of the Year So Far
Looking for something great to read? Browse our editors' picks for the Best Books of the Year So Far in fiction, nonfiction, mysteries, children's books, and much more.
click to open popover

Editorial Reviews

About the Author

Dharma Shukla is an architect at Microsoft working on next-generation programming models. A founding member of the Windows Workflow Foundation (WF) team, Dharma played a key role in defining the architecture of WF. Bob Schmidt is a senior program manager at Microsoft working on next-generation programming models. Since 2003, his primary focus has been on the design of WF. Both authors have been involved with the WF project since its inception, and have been responsible for specifying, designing, and developing large portions of the technology.

Excerpt. © Reprinted by permission. All rights reserved.

Foreword and Preface


As I write this foreword in July 2006, I know something big is about to happen.

Developers are discovering the power of having machine-readable representations of their programs that match their intention. This idea is sometimes referred to using the shorthand phrase code as data.

More importantly, developers are realizing that no runtime architect or language designer is all that qualified to define the schema for that data—a domain expert is the only one who has the right expertise. This idea is sometimes referred to as domain-specific languages.

Systems like Smalltalk, the Java Virtual Machine (JVM), and the Common Language Runtime (CLR) have proven that there is value in having machine-readable representations of type definitions for things such as reflection, serialization, and generative programming. However, the basic representation of a type (e.g., fields, methods, classes) is largely a closed world, which doesn't allow users to model (as data) things such as control flow, concurrency, logic constructs, or domain-specific ideas such as discount policy or dotted whole note except as largely opaque instructions strewn across multiple method bodies.

People are now asking themselves, "If my type definition is available as data, why aren't other design-time constructs as well?"

Fortunately, one of the people asking those questions back in 2003 was my good friend Dharma Shukla, who was then working on the Biztalk Server team.

When the Biztalkers set out to generalize their XLANG orchestration engine as an embeddable platform component, they could have simply taken the language constructs from XLANG and put yet another XML syntax around them (that proposal was certainly on the table). This is the most obvious approach and would have satisfied their charter for building the Windows Orchestration Engine (WinOE) perfectly well.

Fortunately, Dharma had the foresight to know that he wasn't the right guy to define "the one true schema" for all programs and instead decided to "go meta" and steer the project toward building an extensible runtime that allows users to define their own opcodes that match the domain they're working in. Add to this the decision to support defining and composing these opcodes in an XML dialect and you have a system that lets anyone decide what the vocabulary and sentence structure is for describing applications in a given domain.

As Dharma Shukla and Bob Schmidt so aptly show with this book, Windows Workflow Foundation (WF) is an excellent example of a meta-runtime that puts developers in control of how programs are written and how programs execute. The developer defines the schema for a program and then provides an interpretation over that schema to allow it to be deployed and run. It is a simple idea that has huge ramifications.

Like I said, something big is about to happen.

Don Box
July 2006, Yarrow Point, WA


Windows Workflow Foundation (WF) is a general-purpose programming framework for creating reactive programs that act in response to stimulus from external entities. The basic characteristic of reactive programs is that they pause during their execution, for unknown amounts of time, awaiting input.

Reactive programs are, of course, not a new phenomenon. Ever since computers have been organized into networks, it has been useful for programs on one machine to communicate with programs on other machines. Techniques for exchanging data are also applicable to programs running on a single computer. A variety of technologies ranging from sockets to web services has been used over the years to get programs to communicate. Although the interoperability, scalability, and approachability of the programming models at hand have improved greatly over the years, relatively scant attention has been paid to the manner in which developers put reactive programs together. For example, popular web programming models put the burden of enforcing appropriate control flow among operations squarely on the developer. WF attempts to change this.

The focal point of the WF programming model is the concept of an activity—a program statement in a WF program. An activity's execution is inherently resumable and unfolds in an episodic manner, pausing and resuming according to the activity's interactions with external entities. Just as you can stick a bookmark in a page of this book when you are finished reading for the night, it is natural for an activity to bookmark its execution (when it is awaiting input) and then continue right where it left off at a later time (when the relevant input arrives).

WF is a framework, not a fixed set of programming constructs defined by a language grammar. WF's notion of an activity is extensible, which allows the expressiveness and control flow in WF programs to be richer than what is provided by a language like C# or Visual Basic. You can represent WF programs using domain-specific activities and specialized control flow constructs, and thereby capture complex interactions among people and software with a high degree of fidelity to the particulars of the problem being solved.

The WF runtime is a meta-runtime that builds upon the Common Language Runtime (CLR) and manages the execution of WF programs. WF programs naturally pause and resume, and can execute over arbitrarily long periods of time within a distributed (multi-machine) execution environment without any extra work on the part of the programmer. A WF program will neither fail nor cause undue strain on system resources if it sits idle for weeks. The CLR's job, in the context of WF, is to manage objects that transiently represent WF programs while they are in memory. The WF runtime's job is to manage the full lifecycle of WF programs, which can span CLR threads and application domains, operating system processes, and even machines.

In sum, WF provides a programming model for writing and executing reactive programs. WF programs are constructed using domain-specific program statements called activities, which allow domain experts to express their programming intent in the parlance of their domain.

About the Book

There is a simple reason why this book was written. Both of us believe there is a novel synthesis of noteworthy ideas at the heart of WF. These ideas are seeing the light of day for the first time in a mainstream platform. Because WF's activity-oriented programming approach rests on a different set of principles than do today's popular programming paradigms, the best way to learn WF is to focus first on the fundamental ideas around which the WF programming model is built. There is more to becoming an effective WF developer than just familiarizing yourself with the types that reside in the new System.Workflow namespace of the .NET Framework.

To that end, this book does not aim to exhaustively discuss the 350+ types present in the three assemblies that constitute WF. We deliberately disregard some outer layers of WF so as to focus on the essence—the core programming model and runtime feature set. Experience has taught us that learning the capabilities of the framework from first principles is the surest way to becoming a proficient WF developer.

The writing of this book has led us to examine and debate our beliefs and assumptions about the nature of reactive programs and how such programs can be developed. If this book, and WF, provides someone with a fresh idea upon which to build further, we will consider our efforts a success.

The organization of this book is as follows. Chapter 1, "Deconstructing WF," examines the key ideas that underpin the WF programming model: bookmarks, continuations, thread and process agility, passivation, resumable program statements, and a runtime for resumable programs. These ideas are discussed in their barest form, outside the context of WF, to maximize the clarity of the discussions.

Chapter 2, "WF Programs," maps the concepts introduced in the first chapter onto the richer programming surface of WF, and therefore acts as a bridge to the rest of the book. Here we begin developing activities, composing them into simple WF programs, and running those programs.

Chapters 3, "Activity Execution," and 4, "Advanced Activity Execution," discuss detailed aspects of how activities execute including bookmarking, fault handling, cancellation, and compensation. The unifying theme is the activity automaton that describes the lifecycle of all activities. Chapter 5, "Applications," explores how to build applications that host the WF runtime and leverage its points of extensibility. Chapter 6, "Transactions," discusses the critical role of transactions in the execution of WF programs. Chapter 7, "Advanced Authoring," covers a number of advanced topics related to activity and WF program authoring, including validation and compilation, and Chapter 8, "Miscellanea," introduces several feature areas of WF that are built around the previously discussed core concepts.

Appendix A, "Activity Automaton," is a reference for the activity automaton. Appendix B, "Control Flow Patterns," presents the code for several composite activities that are more complex than those developed in the main text. These examples highlight extensibility points of the WF programming model, and demonstrate the capability of composite activities to capture complex control flow patterns.

Our focus in this book is exclusively on Windows Workflow Foundation. We assume prior understanding of C# 2.0 and the basics of the CLR; see The C# Programming Language, Second Edition by Anders Hejlsberg, et al. (Addison-Wesley, ISBN: 0321334434) and Essential .NET, Volume I: The Common Language Runtime by Don Box and Chris Sells (Addison-Wesley, ISBN: 0201734117) for defi...


The latest book club pick from Oprah
"The Underground Railroad" by Colson Whitehead is a magnificent novel chronicling a young slave's adventures as she makes a desperate bid for freedom in the antebellum South. See more

Product Details

  • Paperback: 480 pages
  • Publisher: Addison-Wesley Professional (October 13, 2006)
  • Language: English
  • ISBN-10: 0321399838
  • ISBN-13: 978-0321399830
  • Product Dimensions: 7 x 0.9 x 9.2 inches
  • Shipping Weight: 1.3 pounds
  • Average Customer Review: 3.8 out of 5 stars  See all reviews (23 customer reviews)
  • Amazon Best Sellers Rank: #2,430,177 in Books (See Top 100 in Books)

Customer Reviews

Top Customer Reviews

Format: Paperback
This isn't a cookbook, if it were, it would've say so in the title. It does have plenty of examples, and quite interesting ones at that. I would recommend reading the foreword and absorbing its message before starting the book itself. The programming techniques used in WF have been around for a long time. Anyone who have ever written code in a programming language that supports continuations would find the concepts quite familiar. For me the first few chapters really helped tie the concepts of WF to what I already know. After that it was easy to understand the rest.

If you don't know what continuations are, there are a lot of tutorials and attempts at explaining it on the web. Many web frameworks (Seaside, Cocoon, Uncommon web, etc) are designed around it. WF is Microsoft's crack at a continuations framework.

If you know what continuations are, you will find this book very straightforward.

Bookmarks = Continuations

Consider only the case of single threaded execution (The WF execution model is single threaded), program execution can be thought of as a sequence of actions. In this sense it's like the pages of a book. A bookmark/continuation can be associated with each action in the sequence, so if you need to unload the program from memory (like while waiting for some event that won't happen for a while), you can store the bookmark in a database and restart from exactly where you left off, without having to flip through the previous pages.
Comment 17 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback Verified Purchase
This book describes what is under the hood of WF, elucidating the elegance of its design. It is not a WF cookbook or WF design pattern guidebook. It will tell you the mechanisms by which the activities and runtime services work.
Comment 10 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback
I am writing this review in February 2007, and at this time there are not many options for WF related books.

This book goes seriously deep into Windows Workflow Foundation concepts. The book explains important concepts beyond API calls such as Activity Oriented Programming, Resumable Program Statements, Bookmarks and many more.

Beside the concepts, the book provides lots of practical solution for real life problems. For example I like the solution that this book suggests for synchronizing the Activity thread and UI threads in WinForm applications (Page 204).

I read couple of negative feedbacks for this book and I can guess the reason. This book shouldn't be used to begin and learn Windows Workflow Foundation. However, you will be fascinated by this book if you already know WF well.

In essence, there are resources on MSDN that help you to learn the surface of WF programs in a few days. This book is an excellent resource to take your WF knowledge into the next level.
Comment 9 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback Verified Purchase
This book provides an excellent overview of how the WF architecture is composed and helps advanced developers begin to think in the right frame of mind for designing and building workflow driven applications. What I found really unique is that the authors discuss the reasoning behind every feature discussed in the book. If you read it cover to cover, you'll have an excellent foundation in the unique services, threading model, and extensibility features of WF. You need to take that foundation to your IDE and MSDN and build on the concepts from the book.

However, what you won't get is a bunch of examples, so if you're a code-by-example developer trying to crunch through a project, look elsewhere (try Pro WF by Bruce Bukovics). But if you are a serious architect interested in building a solution around the WF, read this book because examples won't show you how the workflow runtime manages its internal processing queues or unhandled exceptions - stuff you must understand to build the type of robust, scalable application WF is designed to create.
Comment 6 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback
...then get this book. This is an excellent book by the creators of WF. I had been working on WF for a long time, not just by using activities, but building them. However, I never was really confident because while I understood the concepts of activitiy, designer, validator, persistence, I was unaware of many other concepts like what is the threading model (should I make my data structures used in my custom activities thread safe?), scheduler, xoml vs xaml, etc. I used to hit these concepts while designing activities and some runtime extensions and since I didn't completely know, I did not enjoy my work as much. Then this book is released. This book is exactly what I was looking for. Concisely written, but loaded in information. More importantly, it is comprehensive. As I read from chapter to chapter, all my fears about the concepts I only half-understood were replaced by the power of a holistic knowledge of WF I was gaining. There are other books out there which tell you what a CAG activity is and how to use it, but when you are done with that kind of stuff and you don't know where to look further, read this book. With zero exaggeration, I can say that after I read the book, my confidence increased so much that I look forward to work everyday more than ever before.
Comment 5 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
Format: Paperback
Briefly...I have been interested in how WF really works but even after hacking away with the betas and release versions, going to the actual early adopter meetings, and reading numerous blogs I still hadn't gotten as far with the technology as I had wanted. This book opened my eyes to the 'how' of WF and that is what I needed to get out of the woods and right into good workflow coding. Because of the descriptive details that are unfolded on how WF really works, this book seems to be for architects like myself that are required to build some complex systems based on WF. I DO think that the first chapter is awkward. It tries to explain the workflow problem domain by describing in excruciating detail how one might write a simple workflow using standard programming languages. But after getting through this chapter and into the second I realized that the first chapter was necessary for developers that don't know the problem domain at all. I still think the authors could have been more brief in chapter 1 by describing the problem domain in less detail. But the rest of the book, I believe, gives all of the most significant information that the developer community needs to really exploit the technology. Therefore, I highly recommend this work for those needing to understand how WF works and if you need to write custom activities.
Comment 4 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse

Most Recent Customer Reviews