So, you are a seasoned C# 1.x developer very much looking forward to learning the lean mean C# 2.0? Great! But as much as you want to learn the new language enhancements, you despise the fact that any book you pick seems to start teaching you the same old things over and over again; all the features you already knew (or should know); the for loop, the if statement, basics of OO; and therefore you'd have to skip several hundred pages to get to learn a new feature...that is painful.

Like you, I was looking for a book that would teach me the delta, i.e. the differences and enhancements to the new language and not the features that I already know as a C# developer for several years. Written with this upgrade-only concept in mind, seasoned author Jesse Liberty's "Visual C# 2005" came to the rescue. As series creator Bret McLaughlin says "People don't have time (or the income) to read through 600 page books, often learning 200 things of which only about 4 apply to their current job.” This book is the right choice for today’s busy developer who wants the right value for his time.

From the very beginning, this book is focused on explaining generics, iterators, anonymous methods, partial types, static classes, nullable types, limiting access to properties, delegate covariance, contra-variance, enumerators, etc: Concepts you'd want to learn as these are new to C# 2.0. The next chapter talks about IDE enhancements (not necessarily a language feature but it helps), visualizers, refactoring and debugging tools provided with Visual Studio .NET 2005. It just gets better: Web apps, data-driven forms, asynchronous tasks, one click deployment...you name it. In a little over 200 pages, it is a concise upgrade guide to C# 2.0 and Visual Studio.NET 2005 enhancements to support this update.

A Developer's Notebook also talks about security controls, personalization, authentication, master pages, themes, and other ASP.NET enhancements you'd find ubiquitous in all ASP.NET 2.0 books, but without the fluff. I made myself sound almost like the marketing person for O'Reilly but the truth is that I found this book really exciting. As Bret further said "the often-frantic scribbling and notes that a true-blue alpha geek mentally makes when working with a new language, API or project. It's the no-nonsense code that solves problems...." See it for yourself; download the source from http://www.libertyassociates.com/pages/Books.htm and check out code samples, labs, and reference links.

I've also just recently attended Juval Löwy's workshop on Visual C# 2.0 at the DevConnections 2005 conference held in Las Vegas. Along with the conference notes handout, I used A Developer's Notebook as a follow-up reference. Example labs like CreateATypeSafeList, GenericEnumeration, and ImplementingGenericInterfaces were similar to some of the demos performed at the conference. Also, the author, Jesse Liberty is a Microsoft .NET MVP and author of Programming C#, Programming VB 2005, Programming ASP.NET, Programming .Net Windows Applications, and various other books, which explains why the book is so cohesive and contemporary.

Like any other book, it has some shortcomings too. For instance the level of detail in certain topics, but the link section covers references if you are interested in learning more about a specific subject. I think this comes hand in hand with being to-the-point and concise.

If you are not an existing C# developer or want to learn old language features over again, this book is NOT for you. However, if you want to adapt to the new awesome features of C# 2.0 without further ado, there is only one thing to do: Add to cart!

Long awaited Jeffrey Hasan’s Expert Service-Oriented Architecture in C#: Using the Web Services Enhancements 2.0 is finally out. Developing distributed applications has become an increasingly indigenous part of a present-day developer's software life cycle. XML web services provide us an easier and standardized way to facilitate distributed communications. Service orientation takes this to another level, i.e. standardizing loose coupling of these services via contracts. Hasan's book provides answers for today's enterprise needs to learn and formulate their existing distributed communication frameworks as they shift towards Service Oriented Architecture.

This book is about technology we can implement today; it's neither a superficial overview of terminologies nor is it a manager's guide or executive summary. Expert Service-Oriented Architecture in C# is the answered prayer of various developers like me who were looking for a book that comprehensively addresses SOA in Microsoft .NET and couldn't find much help. There are only a handful of books out there on this thriving discipline, Service Oriented Architecture, and most of them fall short in technical implementation details. Most importantly it answered my own skepticism of having another fancy TLA (three-letter acronym) and how it can change the way we program distributed apps today. You'll have to read it to get the answer. Hasan acquired a masters degree from one of the top ten U.S. schools and you'll see the academic excellence in his writing. His technical fluency, vocabulary, and in-depth explanation are salient features that give this cutting edge technology book priority over its counterparts, if there are any.

Expert Service-Oriented Architecture isn't just a good read about SOA but as its title depicts, also a great reference for WSE 2.0. Individual chapters are categorized in a way that each chapter covers a topic of interest; WS-Security, Policy Frameworks, WS-Addressing & Routing, Design Patterns, and so on. Therefore it provides an excellent reference for WSE 2.0, a fairly new release from Microsoft providing support for the latest developments in the Web Services arena. Examples in this book are simplified but not trivial, simpler but not marginal, and the style shows them coming from a software developer who has encountered real world application architecture challenges. Jeffery touched various important topics concisely which a developer encounters either in practice or theory; for instance RPC vs. document literal invocation, web services building blocks, digital signing with x.509 certificate, integrating web services and MSMQ, XML schema definition, etc. The last chapter, beyond WSE 2.0, I found very interesting since it addresses Microsoft's new breed of communications infrastructure built around the Web services architecture and code named "Indigo". WSE 2.0 is here for a relatively small period of time until Indigo kicks in with support for secure, reliable, and transacted messaging along with interoperability. However, future proofing the applications is what Hasan explained in this book, and you have to read it to know it--like Emerson said "Nature and Books belong to the eyes that see them."

If you wrote C++ code for Windows back before the Managed Code Era, chances are that you referred often to books written by the triumvirate of Windows programming authors: Charles Petzold, Jeff Prosise and Jeffrey Richter. Petzold’s Programming Windows was both the standard reference for the straight-C Win32 API and the best source of information on GDI. Meanwhile, Prosise’s Programming Windows with MFC was the definitive work on the Microsoft Foundation Class library, and perhaps the book most frequently cracked open by the typical C++ Windows developer.

Jeffrey Richter’s specialty was the Win32 kernel. His Advanced Windows and related follow-on books offered the best coverage of Win32 architecture and operating system services. They were the places to go to find in-depth explanations of processes and inter-process communication, threads and thread synchronization, memory mapped files, thread-local storage and hooks. They were as close-to-the-metal as one could get without going into the world of device drivers and ring zero.

In Richter’s most recent offering, Applied Microsoft .NET Framework Programming, he retains his unique system-level perspective. There’s very little discussion of application-centric APIs such as Windows Forms or ASP.NET. Yet it would be foolish to attempt to write a professional .NET application without reference to Richter’s book, as it adds the insight and depth necessary to write code that transcends what you can crank out using the typical copy-and-paste programming paradigm.

Not surprisingly, Richter provides in-depth coverage of .NET’s implementation of familiar object-oriented concepts, including types, exceptions, properties, methods and events. Two chapters are devoted to events: a how-to chapter with cookbook-style source code and explanations, and a later chapter that covers delegates, the type-safe function pointers through which .NET implements events. Other chapters detail more architectural features, including metadata, assemblies, garbage collection and AppDomains. I found the garbage collection chapter to be particularly useful, and plan to tweak some of my own managed C++ code to conform to a design pattern for object disposal that he recommends within that chapter.

More generally, you’ll benefit from Richter’s exploration of .NET’s tricky areas. These include boxing, where a primitive type gets promoted to an object, and unboxing, where an object gets cast to a primitive type, topics where his explanations are very informative. I also think you’ll like Richter’s objectivity: he’s clearly a fan of .NET and on-board with Microsoft’s managed code vision, yet is nevertheless quite candid when describing bugs and criticizing design flaws.

I’ll conclude by noting that Richter’s book is not the place to learn the C# language or basic .NET application programming. In fact, Richter’s target reader may have been the former Win32 C++ developer who has learned some C# elsewhere. If you’re new to C# and the .NET framework, you may want to start with the new Petzold book, Programming Windows with C#. Then as you become more proficient, and therefore more curious, you’ll find that a read of Richter will bring you to another level.

The book focuses on systems integration using messaging. Among all the various technologies available to solve the integration problem, messaging appears to carry a lot of promise. Messaging enables separate applications to communicate and to transfer data: it is asynchronous in nature: it requires different approaches (e. g., the application logic is split up into multiple event handlers). Integrated applications run independently, yet coordinate each other in a loosely coupled manner. Asynchronous exchanges of data through messaging offer - despite somewhat increased complexities as compared to synchronous methods - increased reliability through retries, requests throttling and load balancing.

The book is intended for developers and integrators using various messaging products and technologies: Message-Oriented Middleware (MOM), Enterprise Application Integration (EAI) suites, Java Message Service (JMS), Microsoft’s Message Queuing (MSMQ), etc. It should be of interest to application architects and developers, integration architects and developers, and enterprise architects. The examples provided in the book are based on a number of different technologies (JMS, MSMQ, TIBCO, BizTalk). Yet, the authors managed to stay focused on the design decisions rather than the specific technologies. Numerous patterns – solutions evolved through experience and actual use – are provided to the reader. While the reader may be familiar with some of them, it is rather nice to have so many patterns grouped together as a consolidated reference. As the two authors state, this book is the result of a two-year community effort that brought together a large number of people: if anything, this ensured the correctness of the technical content. To quote one of the official book reviewers – John Crupi – "read this book and keep it by your side."

The organization of the book is as follows: the book starts by discussing asynchronous messaging and its advantages and limitations (Ch. 1-2); message channels and message control (Ch. 3-4); message properties (Ch. 5-6); message routing (Ch. 7); message conversion between different formats (Ch. 8-9); message monitoring and management in the enterprise (Ch. 10-14).

The book website has some interesting content to offer as well. Check it out when you have time. Available for download are sets of Visio 5 and Visio 2002 stencils containing 51 integration pattern icons; examples of code; and a PDF version of chapter 3 of the book. The stencils will save you precious time while helping make those Visio diagrams look better.

This is one of the best, if not the best, ADO.Net book I have read. It covers most everything you need to learn to develop an application using ADO.Net. The book is relevant for beginning all the way through expert level developers.

It starts out with the assumption that you know nothing about databases and database programming. There is a good primer on client server systems, relational databases, and SQL. After the intro, it goes into the basics of ADO.Net. It then builds on that foundation and provides in-depth details of the syntax and usage of .Net database programming.

The authors are clear, concise, and explain things very well without being verbose or chatty. There are also many useful and relevant tips throughout the lessons. After you have learned the syntax and functions of ADO.Net, they give you two sample applications, an order entry Windows program and a vendor maintenance web app, that apply the lessons learned in the previous chapters. My one problem with the book is that the code samples do not contain comments, which would be useful with the sample apps. All examples and code are available for download. I haven’t done this yet so I can’t speak to how well the code works.

Besides ADO.Net, there are excellent sections on ASP.Net and N-Tier applications, but what I especially like is the chapter on Crystal Reports. Most every application requires some type of reporting but almost none of the .Net books I read cover the subject. This book devotes 30 pages to Crystal. I wish I would have read this book before I wrote my first .Net app using Crystal; it would have saved me a lot of time.

If you need to quickly get up to speed with .Net database programming, this is the book. It covers most every aspect of database development in a little over 500 pages and despite the complexity and detail of the subject, it is very easy to read and understand. I wish they would write a C# version! I recently converted to C#. It is an excellent book. My compliments to authors Anne Prince and Doug Lowe.

This book is not a great introduction to relational database design and programming, but is what it claims to be: an excellent introduction to SQL Server 2000. If you’re not already familiar with relational databases, then I recommend reading a good book on that topic before beginning this book.

Although this book is called “a beginner’s guide”, it actually delves deeply into several advanced topics. For instance, in the chapter on indices and query optimization, it gives a thorough explanation of the techniques (nested-loop, merge, and hash) that SQL Server uses to process joins. It goes on to discuss the application of optimizer hints in T-SQL. These are probably completely new topics for most beginners, possibly even for some who have used SQL Server for years. The book also includes very detailed coverage of data locking models, backup and recovery models, and Data Transformation Services (DTS). Replication, on the other hand, is given only a modest look; but the book makes up for it with an excellent introduction to data warehousing and how it differs from online transaction processing (OLTP).

This book was obviously very carefully edited, which makes it somewhat of a novelty in today’s IT publishing industry; I reached page 257 before noticing a typo. In all, I noticed only three typos and no other errors in this book of over 600 pages.

The author stumbles only occasionally, when he introduces new terms that are not defined until much later in the book. However, in most such cases the book’s index made it possible to easily locate the definition. Interestingly, some of T-SQL’s most basic keywords (e.g., USE and GO) cannot be found in the book’s index. In a couple of cases, the author mentions a command briefly without providing any information about its syntax; however, the reader can always look up the syntax in the Books Online help system provided with SQL Server 2000.

I read this book as part of my preparation for the Microsoft certification exam 70-229 “Designing and Implementing Databases with Microsoft SQL Server 2000 Enterprise Edition,” and though I haven’t taken the test yet, I feel confident that reading this book went a long way toward making me ready. The book even includes exercises at the end of each chapter with solutions in an appendix, making it even more suitable for exam preparation.

Postscript: Thanks in large part to this book, I passed the SQL Server 2000 exam (070-229) on the first try on Apr 9, 2003.

All in all, this 900-page book is a reasonably good way to begin learning ASP.NET. It is equally as good for C# programmers and VB.NET programmers, since nearly every one of the many examples in the book is listed in both languages. This approach can be especially useful to those who wish to learn both languages, though it uses up a lot of pages—nearly half the book is example code. (After a while, the reader realizes that most of the code is virtually identical in either language, and usually flips right past one language or the other.) This extensive use of example code in two languages helps to explain how a 900-page book could be a mere introduction to the topic of ASP.NET programming.

Aside from the book’s language duality, its other most significant feature is its nearly 200-page introduction to ADO.NET. This section provides many examples, including some advanced topics, such as the use of either database transactions or connection-based transactions to ensure that data remains in a consistent state.

The book contains several typos and other minor errors, but no more than the average book of this sort. There are also a few instances where the authors gloss over a topic, leaving the reader wondering how or why what the authors say makes any sense.

Finally, the book includes only a cursory explanation of regular expressions, a topic of increasing importance to today’s web developers, who must defend their web servers from potentially malicious user input. Other important ASP.NET topics, such as exception handling and the use of page inheritance, are missing entirely from this book, which should probably be subtitled “A Beginner’s Guide.”

Programming Visual Basic .NET by Dave Grundgeiger introduces application development on the Microsoft .Net platform. Conceptual overviews of the .NET philosophy are mixed with procedural steps designed to walk readers through basic programming tasks and code fragments that illustrate specific Visual Basic .NET features. Programming Visual Basic .NET contains eight chapters that cover the Visual Basic .NET Language, the .NET Framework, Windows Forms, Web Forms, ASP .NET, ADO .NET and Web Services.

The introductory chapter is modeled on the ‘Visual Basic Version of Hello World!’ topic in the Visual Basic .NET Help system. Three different .NET application types are presented in the context of a simple programming specification. Command-line compilation, windows form, and web form applications are demonstrated.

Mr. Grundgeiger uses the command-line compilation example to introduce the concept of a namespace, use of standard modules, and the Main subroutine. He instructs the reader to compile from the “Windows command line”. However the Visual Studio .NET Command Prompt is the correct tool to use when compiling a .NET console application. The distinction is critical because .Net applications cannot be compiled on the Windows command line as it does not reference the .NET Framework.

The .NET Language chapter provides a good introduction to the syntax of the Visual Basic .NET language. Conceptual overviews are supported by code fragments. However if the reader wants to experiment with the code fragments then s/he must type them into the IDE. The unavailability of code samples in electronic format is a drawback. For example, the ability to copy and paste code would have been more than welcome during the discussion of validation techniques and server controls in the chapter on ASP.NET and Web Forms. The code for that example is reprinted in the book but it runs on for five pages. The prospect of typing it all up conflicts with the momentum of reading the book.

O’Reilly books are not sold with CD supplements glued to the inside back cover. We are, however, told in the preface “that there is a webpage for this book” and that it contains “errata” and “examples”. In fact the webpage dedicated to Mr. Grundgeiger’s book does not offer any code. O’Reilly encourages customer contact so I emailed them about this issue and received a prompt response acknowledging the problem. Also, a few serious readers have submitted error reports related to code samples in the book. To date the errors remain unconfirmed by the publisher.

An important discussion in the .NET Language chapter concerns passing arguments to and from methods and arrays by value and by reference. Mr. Grundgeiger explains that when an argument “is passed by reference, the address of the argument is passed to the routine” and that when an argument is passed by value "a copy of the argument is passed.” The author then warns us to “be aware of the effects of ByRef and ByVal on arguments that are reference types.”

This warning is followed by an interesting code sample that is compromised by an editorial error. A variable is declared in one class and then two instances of that class are instantiated in another class. The purpose of the sample is to demonstrate that when an argument in a derived class is passed by value the parameter in the calling method is exposed to change regardless of the fact that it has been passed by value. Unfortunately the code in the calling method invokes the ByRef subroutine twice when the author is in fact describing the results of a reference pass followed by a value pass.

I was able to work through the example and rescue the technical point by referencing the Help system. The ‘Argument Passing ByVal and ByRef’ topic provides close coverage of the intricacies of passing parameters: “Passing arguments by value and by reference is not the same distinction as the classification of data types into value types and reference types. However, the two categories do interact.” The ‘Argument Passing Mechanism’ topic in the Help system is also worth reading.

There are two chapters on Windows forms that provide a basic introduction to controls, events, signatures, MDI applications, and menus. Mr. Grundgeiger demonstrates how to create Windows forms using the Windows Forms Designer as well as by writing code in Notepad and compiling the application on the Visual Studio .NET command line. The exercise of writing a simple windows form application from scratch is very instructive because it gives the reader a clear view of how a simple application hangs together in the .NET Framework.

The book lacks a consistent presentation style. Sometimes the editors use numbered procedural steps to outline a programming task. At other times the procedural steps are simply described in narrative prose in a paragraph. This stylistic inconsistency detracts from the overall friendliness of the book.

Brief introductions to ADO and Web Services are followed by five appendices. One of the appendices consists of a five page list of culture attributes. A discussion of the challenge of designing and developing software products that function in multiple cultures would have added to the value of this list, which seems like filler the way it is presented.

In the preface Mr. Grundgeiger states that “the purpose of this book is to provide experienced software developers with the means to quickly become productive in Microsoft’s Visual Basic .NET development environment.” O’Reilly, Mr. Grundgeiger’s publisher, declares a slightly different purpose by stating on the back cover that the book is “targeted at programmers with some prior programming experience, particularly in Visual Basic.”

Code sample errors and inconsistent layout appear to be the logical extension of an editorial touchstone as inconclusive as the phrase “programmers with some prior programming experience.” How seriously would a legal book be taken if it were described as a resource for lawyers with some prior experience of the law?

Time spent with Programming Visual Basic .NET by Dave Grundgeiger could provide a profitable return on investment if the reader is willing to troubleshoot code samples and supplement the text by researching .NET concepts in the Microsoft Development Environment Help system. Caveat emptor.

Good introduction, but only takes you so far…

This is a good introduction to VB.NET, but I think some better, more detailed books have been published since this one. This book has many minor errors. Gary Cornell posted several dozen corrections on the Apress web site, but I'm sure I found just as many errors that have not yet been corrected. Most of the errors are just typos, so I guess that shouldn't keep you from buying the book. However, I think Apress should try to improve their editing.

More importantly, nearly all of the example code in the book is of the "Hello, World!" caliber. The code demonstrates the concepts ok, but generally is of little use in a real-world application. For instance, I don't think I'll ever have need for the Knife and Fork classes or the Programmer.Eat method, but I could be wrong. I've also found little demand for foo and bar classes in my part of the country, but maybe we're special. I think you could find another book with much more code that could actually be reused.

Also, the book does not come with a CD. You can download the code from Apress, but there is no electronic version of the book available for searching. If you're looking for a VB.NET reference to use over and over, I think you should find one that includes an electronic version you can quickly search.

Lastly, the final chapters of the book are extremely short and cursory, hardly more than long magazine articles really, barely covering important topics like database access, ASP.NET, and COM interop. If these topics are important to you, this book is not the one for you.

I bought this book in January 2002, but if I were shopping for a VB.NET book now I'd be looking at these authors: Francesco Balena, Andrew Troelsen, John Connell, or Mike Snell.