The Windows Communication Foundation is one of the fundamental key components of what is now called .Net 3.0.  However, this enhancement comes with a price, a steep learning curve. Without this book by Juval Lowy I doubt many programmers would have the proper guidance necessary to make good design decisions. You see that is what Juval Lowy set out to do in his latest book and I think he did a fabulous job! This book is not for the novice programmer it should be warned, but rather the experienced developer who desires to push his or her skills to the next level.

From the very first chapter this book had me hooked. I rarely read technical books all the way through in one sitting however that is exactly what I did with this book. The first chapter starts to explain in plain English what WCF is exactly and from then on the content just gets deeper and deeper.

Now it must be said that I am not an software architect by any means however this book helped to give me more of an architectural viewpoint which could only improve my skill set. The design guidelines and best practices are clearly laid out so that anyone with some programming experience should be able to understand. This is not your average computer text which gives a chunk of code and then explains what it does.  There really is nothing average about this writer and book.

If you believe that anytime in the near future you will need to understand WCF for your work I would highly recommend picking up a copy of this book. It is not for the feint of heart but the journey is well worth it.

The Windows Workflow Foundation is part of what is now .Net 3.0. Since this is the direction that we all seem to be heading in getting some solid information on subject is paramount. Fortunately we have a good resource in the book Foundations of WF by Brian R. Myers.

The premise of this book is to provide an introduction to the concepts, techniques and quirks of the Windows Workflow Foundation. It is not an exhaustive text explaining every nuance of the framework. Rather, this seems to be a somewhat of a high level approach of introducing the subject matter.

Throughout the text of the book plenty of example code is provided. As I really have no means at this time of testing the code myself I can not validate its accuracy. I am assuming the technical editors of the book have already done this but I have been fooled before.

What I did find disappointing is that only one chapter covers the integration with the Microsoft Office Server System 2007. This is disappointing to me as this is the new realm of where software developers are now able to venture into. However, I would like to point out that this chapter does cover the subject matter fairly well however it would be nice to see more titles from Apress covering this subject.

To give an overview of what is covered I will include the table of contents as such:

Chapter 1 – Introduction to Workflow and Windows Workflow Foundation

Chapter 2 – First Workflow

Chapter 3 – Conditional Activities

Chapter 4 – Flow Activities

Chapter 5 – Rules Based Workflow

Chapter 6 – Workflow and web services

Chapter 7 – Interacting with workflow

Chapter 8 – Custom Activities

Chapter 9 - Deploying Workflow Applications

Chapter 10 – Employee and performance review application

Chapter 11 – Integration with Office 2007

The chapter covering the reference application is actually also quite good. The application is not something I would deploy in a real world scenario per se but it does cover many of the fundamentals necessary to get a firm grasp of the concepts in action.

Overall I believe this to be a good work and worth the money if you wish to be introduced to Windows Workflow Foundation. However if you are looking for something more in depth look elsewhere as I believe more in depth texts are starting to become available.

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

Recently I have had the pleasure of reading a great book called Accelerated C# 2005 by Trey Nash. I found this book to be both insightful and informative on many levels. Now I am already familiar with C# 2.0 so this book did not necessarily teach me anything particularly new to the language. However the points that Mr. Nash brought out while using C# have helped quite a bit.

This book is not your normal C# training manual. Rather, the approach of the author is to take you through the language as if you were an already experienced programmer. I find that approach to be a bit refreshing from the standard explain a bit about a subject, show the code move on approach to writing these types of books.

Of all the chapters that I found to be particularly good were the chapters on Generics and Delegates. Generics are still a new subject for me and any new insights I can get on how this is supposed to help is much appreciated! The material in that chapter I believe to be worth the price of the book alone.

To give you a listing of what is in store if you should buy this book here is a listing of the table of contents.

Chapter 1 – C# Preview

Chapter 2 – C# and the CLR

Chapter 3 – C# Syntax Overview

Chapter 4 – Classes, Structs and Objects

Chapter 5 – Interfaces and Contracts

Chapter 6 – Overloading Operators

Chapter 7 – Exception Handling and Exception Safety

Chapter 8 – Working with Strings

Chapter 9 – Arrays, Collection Types, and Iterators

Chapter 10 – Delegates, Anonymous Functions and Events

Chapter 11 – Generics

Chapter 12 – Threading in C#

Chapter 13 – In Search of Canonical Forms

The final chapter of this book, chapter 13, was particularly good in defining some of the best practices when designing and building software. The revelations that this chapter showed me I believe in the long run will help me to be a better developer. Now I do not necessarily agree with all of the best practices outlined in this chapter I will give it some thought when designing software in the future.

Personally I would recommend this book for anyone wanting to get into writing C# programs rapidly. This book is however designed for an experienced developer and I would recommend if you are new to programming that you shy away from this book to start and then later pick yourself up a copy.

I have recently became a fairly avid user of the CSLA.Net framework by Rocky Lhotka. I find that the framework fills in some of the gaps that I need when I am developing applications. Since I am somewhat new to this framework I am just happy as all get out that there is a new forum where I can ask questions regarding this piece of code.

The forum can be reached here:

http://forums.lhotka.net/

It is powered by Community Server which is also something I am a bit of a fan of as I hope to eventually start a community based programming site with it when I get the time.

So if you have any questions regarding this particular framework and how it may be able to help you or at least clarify some issues that was not covered in the books then this is the place for you.

Just a short note right now I guess.

Just a quick note that since Rocky Lhotka has sent his book off to publishing you can now get the source code for the next version of CSLA.Net 2.0 from his website. This is good news for all those using .Net 2.0. I have not yet had the chance to download and inspect it yet, because I am writing this blog post instead! <G>

You can find the code here.

When the book comes available I am sure there will be a much better explaination of how and why we should use this code framework. Enjoy!

Published by: Apress

Author: Eric White

Introduction:

It is stated in this book that this book is for developers who wish to enhance their programming skills in order to create custom controls. The primary language for this book is C#, this is most likely just a personal preference by the author of the book and it should not really adversely affect any other developer who writes code in other languages. Basically the techniques in this book can be applied by any Visual Basic .Net developer or even an Visual C++ .Net developer. The approach the author chose to take is to first give a brief introduction of what GDI+ actually is and then dive into the nuts and bolts of the underlying framework of GDI+ and then finally go into the architecture and development of Windows custom controls.

It is important to note that the source code for this book is available online at the APress website. You must download the code yourself if you want to see examples the coincide with each chapter of the book.

You can download the source code here:

Chapter 1: .Net Graphics Programming

This chapter provides a good introduction of .Net graphics programming. All the necessary topics are covered for even the most novice programmer. The highlight of this chapter is the overview of the namespaces of GDI+ programming which are listed in the table below.

An overview of the basic of custom controls is also covered in this chapter quite well.

Chapter 2: Drawing Surfaces

This chapter covers what to consider when drawing to specific target environments. These target environments are a window on a screen (known as a form), a page (sent to a printer) and an image (such as a bitmap) since these all can be drawn to by pixels it is important to note the differences between these drawing surfaces simply because not doing so can affect your program in a very negative manner. I have personal experience debugging a C++ program that had its share of pagination issues and I have to note that many of those issues were most likely caused by the poor translation from one drawing surface to another.

The author does a fairly good job in explaining how to deal with each target environment. However as this is an early chapter some points are purposely left to other chapters to fill in. As there is a complete chapter printing it is wise to reason that the more in depth discussion of that drawing surface would be covered in more detail in that chapter.

Chapter 3: Pens and brushes

This chapter builds on the previous one in that it describes how to actually draw images on the screen using pens and brushes. Pretty much every aspect of the task of using pens and brushes is covered exhaustively in this chapter. Also, when covering this topic the author makes sure you understand how these methods are interacting with the screen, printer, etc to make absolutely sure you take all considerations into effect before setting down and using this namespace.

Chapter 4: Text and fonts

This chapter is perhaps the most drawn out text on fonts and text I have ever seen. Now this is not necessarily a bad thing as without text no information can be conveyed to the end user. Furthermore, the first GUI interface main attraction was the use of the fonts only seen in well published novels and magazines. Again every aspect of the namespaces that control how and where text is laid out on the screen or printer is covered very well in this chapter.

Chapter 5: Images

The use and manipulation of images is covered exhaustively in this chapter. However I would not use this chapter as a sole resource on the subject of image manipulation. Rather I would turn my eye to the open source projects that do the same thing but in an actual application. This would be something like the open source project Paint .Net. You can use this chapter to get a better understanding of what is going on in the underlying code in the project but since the examples are rudimentary and elemental at best it is far better to see this code in an end product such as Paint .Net.

Chapter 6: Graphics Paths and Regions

Now this chapter was interesting as it covered regions which can be used by Windows Forms as a way to create a more customized user interface and hence user experience. Again, an exhaustive coverage of the material is covered. With this understanding hopefully you will have the knowledge to better manipulate the regions and graphic paths in your programs.

Chapter 7: Clipping and Invalidation

Not a whole lot to say about this chapter except that the same exhaustive coverage of the material is continued with this chapter.

Chapter 8: Transformations

Again not a whole lot to say about this chapter except for the same exhaustive coverage of the material is continued again with this chapter.

Chapter 9: Printing

This was a special chapter for me as I worked on a project in my senior year at college that dealt with issues on pagination in a visio like program. Some of the same techniques I employed to debug the program were illustrated in this chapter. Ofcourse I was using MFC at the time and did not have access to the .Net framework but the techniques employed here would apply to many languages.

Chapter 10: An alternative coordinate system

This chapter explains the authors use of his own coordinate system in order to solve issues he found while covering the previous material. Pretty much every method that you expect to see in the .Net 2.0 framework is repeated here but with the author’s own unique twist on things. I am unsure of the real benefits of this coordinate system as there really is no whiz bang examples that really make me believe that this is the way graphics programming should be done. Really this is my biggest complaint of the whole book is that the author does not really develop any really useful program that the reader would want to use in their everyday lives. Personally, I need to see how these coding techniques are put together in a real live program in order to maximize the benefit of the learning experience.

Chapter 11: Architecture and design of Windows Custom Controls.

Finally the meat of the book and it took 11 chapters to get to it! This is really disappointing. Not the content of this chapter by any means but the fact that it took 11 whole chapters to discuss what I believe is the main crux of the work, Windows Custom Controls.

Now while this chapter does employ simple examples to illustrate the point it is trying to convey I would love to see some meatier examples, perhaps in an extended appendix or online on the Apress website.

Chapter 12: Design time support

What is design time support? This is where the end user of your control has the ability to dynamically control the properties of your custom control. Since you are designing for another programmer you must consider all the ways to enhance the experience and increase the development time of the programmer. This chapter does a fine job explaining these techniques and through the simple examples the point is made clear.

Chapter 13: Scrolling

Now when I got to this chapter I thought, why devote an entire chapter to scrolling? After reading the chapter I was still left with that question. In the very beginning of the chapter the author explains that there is considerable amount of built in support in Windows Forms for scrolling. So why would you want to do it yourself since it has already been done? While this chapter does an excellent job of explaining how to implement this in your own custom controls I can only justify this chapter as a filler chapter.

Chapter 14: Mouse event and cursors

What is a graphical user interface without the mouse? Not much in my book. This chapter explains how to properly utilize this input device as it pertains to your custom control. Since this is the last chapter of the book I was expecting some sort of wrap up, however there was none. No really great words of wisdom from someone who develops custom controls on a daily basis, none of that. Somewhat disappointed.

Overall impression of the book

Now admittedly I am not a great graphics programmer by any means. However this book will certainly teach you the nuts and bolts of GDI+ programming. How that will benefit you is up to your own judgment.

Where this book needs improvement on is that fact that there is not one single project the reader can build upon in order to learn the concepts taught in this book. Also when the reader does get to the meat of the book the content is left hanging by excruciating examples that most readers will be able to find by doing a simple