Customer Reviews

Professional WinFX Beta: Covers "Avalon" Windows Presentation Foundation and "Indigo" Windows Communication Foundation (Programmer to Programmer)

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

 

 

While there is practically nothing else available on WinFX, this book is a worthwhile purchase. It is difficult to escape the impression though, that the authors did not want to put much effort into it, because it is a beta product and book would be worthless when the final product is released. It would have made more sense to create a good reference that only needs tweaking for the final product.

At best, the book is skimpy. At worst, it is full of holes, such as references to “the configuration file” without specifying which configuration file. The reader is left to try to fathom whether it is the client application's config file, the server application's, the web.config file, the machine.config file or one or more new ones dedicated to Indigo.

The style of the book is just sufficiently strange to make reading it slow and difficult. Mostly, it is not difficult to understand (though I did find one sentence that nobody could decipher, not even in context), but phrasing is just different enough to make you pause and check that it is saying what you thought it was.

For example, program language elements and function names are almost universally in a different type face to regular text, but then one finds, “A double type valued property...” that is all in the regular type face. What is this? I assume it is, “A property with a type of 'double'”, but one has to pause to check that there are no other reasonable meanings.

There is no background information in the book. For example, there is no explanation or speculation on why Microsoft might have chosen to create a new layout markup language (XAML) when there are other good standards in existence.

There are some really weird features that are not explained, not well described and not even acknowledged to be weird. An example is “dependency properties”. There is no explanation of why these exist or why conventional properties would not do. The description says they are 'static' methods, but all the examples show them being referenced as 'instance' methods and there is no explanation of this anomaly. There is a variety called, “attached dependency properties” that are “attached” to a container, just as a normal property would be, but is referenced by contained items, again, as a normal public property could be.

If an item, such as a button, is placed in a container, such as a canvas, one does not specify the position of the button relative the container's boundaries using the buttons position properties, as one would logically expect and as one would with the major, standard markup languages. Instead one specifies the button's position at the button level, but using the container's position properties. Strangely, this does not change the position of the container (canvas), but of the button. Furthermore, one can place another button in the container and specify its position using the same container's position properties as before and neither the container, nor the previous button changes position.

This approach also introduces the annoying effect of not being able to move a button from one type of container to another without also having to change its position specification. Overall, this approach is counter-intuitive and apparently a step backwards. It may be that Microsoft has uncovered some flaw that has eluded the rest of the world, but the book is totally silent on this.

One can learn from this book, but I don't feel I really understand WinFX or that I could comfortably deploy a WinFX application after reading it.

Very simple and clear intro into the new Microsoft technologies as WCF and WPF but the book lacks deeper description of internal mechanisms on which those technologies are built. I'd rather call this book not "professional winfx" but rather "introduction to winfx" of "beginning winfx".