A few months ago, I read my first book in Addison-Wesley's "Microsoft .NET Development Series" titled Graphics Programming with GDI+ by Mahesh Chand. I knew his name as the founder of c-sharpcorner and figured it'd be a great read. I was right. Well, I've read a few more of their titles and I have to say that this is far and away the best series of books published today.
If you have any experience with Visual Basic, then you'll certainly know the names of Francesco Balena and Rockford Lhotka. Well, the books begins with glowing reviews from both of these guys, and that says it all.
The book is 562 pages including indices and tables. The first two chapters are you obligatory "This is what .NET is" chapters and then things get crazy. If you are totally new to .NET, I think it might be a bit overwhelming, or you won't really appreciate it fully. Having programmed with .NET for over a year and a half when I read it, I was amazed. Chapter 4 starts talking about Arrays. One would think this is pretty standard stuff. Well, there's not one thing you can do with an array that isn't discussed here. And this is pretty much the tempo of the rest of the book. From there, he moves into classes. The topic of Shared Members versus Instance Members has 11 pages dedicated to it. The fact that he can write 11 pages on this subject and command your interest is a statement unto itself.
Next he moves into the subject of Classes that is one of the slower parts of the book. The main value of the initial discussion resides in the clarity of the examples he uses. I don't think this is really a beginners book, but it's sections like this that make it attractive to multiple audiences.
After this brief lull, he gets into Abstract Classes and Interfaces. He really explains the uses of Abstract classes and once again, the examples say it all. Interfaces play such an important part in the .NET framework, and his discussion there (coupled with the examples) will definitely get you up and running if you had any questions. If you are an experienced VB6 programmer and have a good grasp of OOP, this part of the book will prove to be pure gold. Interfaces weren't a big part of VB6 so it takes a shift in thinking to appreciate them (unless you were a C++ programmer too, but that's another issue). Then he hits you with Delegates and Events. I had just read Paul Kimmel's Visual Basic .NET Power Coding (another Home Run from AW although not part of this series), and really liked his discussion of delegates and events. I can't really tell you whose discussion I liked better, but both explain these concepts clearly and thoroughly. Kimmel emphasized asnychronous methodology more, but Pattison is really heavy on examples that will clear up any confusion you might have.
From here he moves into exception handling and as far as I can remember, he's the first author I've seen who really emphasizes the benefits of using the "When" clause within a try catch block. You can tell that this type of precision can only come from an complete understanding of one's code, but it's a hard concept to ignore. And I think if there's one overriding theme of this book, it's really getting to know your code inside and out. And trust me, after this chapter you'll probably realize that you don't know your code nearly as well as you may have thought.
The book then really takes a big turn to the subject of building and deploying apps. He goes through using .config files but focuses mostly on Versioning. Then comes "A Brief History of COM". If you aren't familiar with COM , you'll quickly come to realize that .NET is probably one of the best things that's happened to you. If you are familiar with COM, you've already come to realize that. Although his intent here isn't to show you how to build a setup project, he really gets into the conceptual considerations of building and deploying applications and you'll be glad you read it.
He concludes the book a discussion of COM Interop which is kind of surprising. I'm not really sure why it comes at the end, but I guess with the flow of the book, it works. Until the framework matures some more, chances are that you'll run across COM Interop and this is a great reference point. Probably the best part of the chapter is his discussion of the ComClass attribute but the whole thing is a pretty good read.
All in all, this is without a doubt one of the best books I've ever read. It's thorough yet concise and never boring. I can't wait for his next book!