Customer Reviews

Foundations of WF: An Introduction to Windows Workflow Foundation (Expert's Voice in .NET)

5 star:		(1)
4 star:		(2)
3 star:		(2)
2 star:		(7)
1 star:		(5)

 

 

I purchased this book because WF is a brand new technology and there were very few resources in this technology at the time of my purchase. If you find yourself in the same boat then save your cash and wait for something better.

I am not one of those reviewers that will give a book a 1 star review because of a few grammatical errors, or small issues. I truly believe that this book is dangerous for new developers. Let's discuss:

First, the formatting of his code is very poor and inconsistent. He generally uses three different formatting techniques. Such as this... (Code not copied directly from book, but very similar, page 126 for an example)

If MsgBox("Do you approve...etc") = MsgBoxResult.Yes then
RaiseEvent Approved (nothing, nothing)
Else
RaiseEvent NotApproved(nothing, nothing)
End If
End Sub
Private Sub ApproveReview(ByVal...etc)
MsgBox("...etc")
End Sub

As you can see this is very poor formatting with absolutely no indention or white space between methods. It's very hard to read, especially since this is a very small snippet of the code in question.

Sometimes he formats his code correctly. Other times he does weird nesting techniques and shows if statements as if they were nested if statements, but they're not. For example (sorry about the periods, Amazon doesn't format whitespace correctly)

if(Condition)
....{
....DoSomeStuff();
....}
....if (someOtherCondition)
........{
........DoSomeOtherStuff();
........}

First the formatting looks funky as it is, but also the second if statement looks as though it might be nested inside the first if, but it's not... it's a totally separate if statement that has nothing to do with the first.

Formatting is not my only complaint with this book. The biggest problem with this book is poor coding. Very poor coding. For example he has if statements that nest up to around ten levels deep, when nesting is not even needed! In fact, the nesting often creates undesirable side effects where the users could be caught in a lengthy loop of seeing error messages one at a time (page 59 for example). Other techniques could be applied that would make this much more user-friendly. Also there are many other pieces of code that leave me wondering how much experience this guy really does have. HUGE try-catch blocks where there's a bunch of unnecessary code inside of the try block is another example. There are many code examples in this book that will leave experienced programmers wondering why he approached situations the way he does. This is very dangerous for new programmers because they may adopt these techniques. One more example, he uses a lengthy case statement on page 21 where it appears to simply create leading zeros for a number. So it's like

select case number
case is < 10
num = "00000" & orderID
case is < 100
num = "0000" & orderID
case is < 1000
num = "000" & orderID

...etc

I hope he learns about the String.Format method because that would cut out about 15 lines of code and would be more flexible. I am only bringing up so many examples because I want to really illustrate that Brian Myers does not provide good code examples which can be dangerous for the new guys as they too will adopt these terrible coding techniques. Seems like every routine he writes has something weird about it.

Believe it or not, there's more. As if poor formatting and coding wasn't enough. This book is chalk full of filler. He will explain an idea (which isn't language specific) provide VB code, then explain the idea again and provide C# code. In most of these instances he could simply explain the idea once and then show the VB code followed by the C# code. Of course, that only applies when he does provide C# code. He also uses padded sentences and large screenshots that aren't necessary. It's very obvious throughout this book that the author feels more comfortable in VB. About 60% of the time he doesn't even provide C# code, not even in his "Real World Examples" (which aren't real-world by the way), which leaves us C# guys out to dry and makes us decipher all of the VB code. Not that it's too hard - it's just annoying.

Since there is so much filler (trust me, there's plenty) and this book is only 224 pages long (not including the index and what-not) then it's expected that you barely even scratch the surface of what WF is capable of. I could rant all day about what's wrong with this book. You can see by checking all of the reviews I've written that I've read plenty of software books, also consider that I haven't written reviews for EVERY software book I've read. With that in mind, I must say that this is the worst software book that I've read to date. I don't understand how anyone can give this book a good review.

On a positive note I want to say that Brian was under a target date with a new technology, and that's something very hard to work on, but...

This book has a lot of things that for someone who might be new to programming, could jeopordize there learning. For whatever reason he tries to provide some terminology of OO concepts in a few places throughout the book which are unforutantely way off the mark, and perhaps it's the way it was written; but within the first chapter or two I saw something about creating a new object and having it referred to as encapsulation - which is way off. I also read a few things that could be easily mistaken by the novice developer...such as 'the message box pauses the workflow'. Yes, because it's a modal dialog box it makes the workflow 'appear' paused - the novice developer doesn't know about this and the way it is written may think that a message box actually 'pauses' the work flow runtime. The use of nested if statements where there should be case statements is horrendous and the C# was obviously not reviewed, there's brackets in places that there's no need for brackets and the author even writes that there is no equivelant in VB...probably because you would probably not put it in C# to begin with. I also read another review where they point out the lack of using String.Format and combined with the above the fact that young developers might be reading this accepting what is written as fact is a scary proposition.

So for Brian I have two things; first applause for taking on a very new technology very early in it's life cycle; the challenge of this task is immense. Second, leave OO concepts in a book about OO, stick to the subject. For Apress, keep VB books in VB by VB developers, keep C# in C# books by C# developers...most VB people I've met aren't very interested in C#, and the C# people I know, including myself only use VB if directed to and can easily transform there C# to VB when needed; so there's not any value, to me at least, in having a book that has both languages...this book would be 1/2 the size without writing the same thing in two languages, and it's pretty small for a technology book to begin with.

For the content of the book it leaves a lot to be desired, I'd say this is a good book for someone who knows absolutely nothing about WF (including not watching any MSDN videos) and wants some hands on. And that's exactly what it's done for me, and that severely disappointed me. There is not a lot of 'why' you would do this or why you wouldn't do that type of discussion; and it doesn't do much to help fight the silver bullet mentallity that plagues our industry because WF is not the right answer to every problem. Maybe that's in the 'PRO' book.

Bottom line is that it's a good introduction to WF but unfortunately has the potential to lead young developers astray quickly. But to be honest you can get the same level of content on the Virtual Labs on MSDN and save a few bucks.

This book covers the basics of the different activities and will give you a generally quick introdution to WF. I gave it 3 stars because of the numerous typos. Also beware in Chapter 7 on CallExternalMethod. Neither the C# or VB code will work. The C# code is the closest but as a brand new beginner, it took me hours to figure out what was wrong. I accidentally discovered the Microsoft samples and a post on the quirks of external calls. Between the three I finally got a working program. Proabbly good for me from a learning perspective but not what I usually look for in a book.

Brian's book successfully delivers what it promises - an introduction to WF. It definitely does not target the experienced user (there is Pro book for them) who should stick to the Internet and the official Microsoft documentation but that is not the target audience. For those people who like a little more hand-holding when embracing a new technology this book can be recommended.

This is not a great book. There's a certain amount of "filler" but unfortunately that's true for most computer books - I don't think this one is worse than others. The typos are not that bad until ch7 where the Events example doesn't work at all. In the C# version you get an exception and the VB version is pointless as the intended event delegate is never called, instead the service class subscribes to its own events(!).

To fix the C# example, in Program.cs, replace this line:

workflowRuntime.AddService (LocalService);

with these three lines:

ExternalDataExchangeService exchangeService = new ExternalDataExchangeService();
exchangeService.AddService(LocalService);
workflowRuntime.AddService(exchangeService);

Overall I don't recommend this book. If you only want an overview of WF you'll get that but the book will leave you confused as to what WF is good for (e.g. why do something in 100 lines that you can do in 5 lines...). I think you need more than an overview of WF in order to "get it".

First of all this is not foundational work at all.
I guess this title maybe confuse many readers like me since tht title
suggest more like fundamental coverage of core issues related to WF.
But rather (I was surprised too) it is only available step by step
walk trough of many important and basic stuff.

If you are looking for the deeper understading of underlying tech look for
"Essential workflow foundation". But for me this book offers what is missing in "Essential workflow foundation" and online stuff.

You can familiarize yourself to "Desinger oriented" construction of workflow rather than programming or xml oriented. Also good coverage of
ExternalMethod in chapter 7 also unique exmaple integrating office to WF using sharepoint.

The book is methodical, easy to read, clear, simple, and I found it a pleasure to read.

It offers a broad sweep over Workflow, and is a very good introduction - perhaps the best I have seen so far. To the seasoned Workflow developer, this book may nevertheless be a bit thin on the ground, but the intention of the book is to provide "Foundations".

The source code for each chapter is available on the apress website. Unfortunately, there are some errors in at least one of the solutions (I reviewed the code for Chapter 10, which is a "real world application" to demonstrate WF using a state machine performance review system). Perhaps the apress people will fix the source...

Sharepoint example is a bit thin, but very worthy. It is a great bonus to Brian for having this in, and a good starting block for getting into Sharepoint Workflows.

Generally, the book is comprehensive, and covers the basics. If you are looking for more depth, however, I think that the next book from apress, "Pro WF : Windows Workflow in .NET 3.0" will be better. Among the missing topics in this book are batching, tracking services, dependency properties, changing workflows, roles, queues, correlation and perhaps a good few more.

Overall, a very good foundation book, and worthy of being on the shelf of anybody interested in Workflow.

I award this book four stars, just because the source code was faulty - and perhaps the solutions could have been a bit tighter around the "core" - e.g. too many non-essential web pages in Chapter 10.

Unfortunately this books lack many of the details. It doesn't cover tracking services at all. Many of the ancillary services are lightly touched on - if at all. Need to query your workflow to see where you're at? Good luck.

I spend money on books to save money doing research and I walked away from this book shaking my head. Sadly, I haven't found a better resource in print.

I have purchased the only other 2 workflow books I could find on the market right now, and this is the 3rd one, and so far the most helpful. The example code in this book gives you a nice foundation to start your own workflows. The other books I have purchased were much more indepth in how it works and why but now enough code to tell you how to do what I now know it can do. Thats why I feel this book is the best one out right now, not only does it go over a foundation of what workflow is and why you would want to use it, but it shows you how to use it as well.

I read this book trying to decide if I wish to use this technology for a new project. While reading it I got the feeling that this was more "promotional material" about WF than a technical book. It felt more like a brochure than a serious book.
After reading it, I did not feel confident enough to use the technology. Still don't. I will have to agree with the other reviewers: This is not a high quality book.