Stephens' C# Programming with Visual Studio 2010 24-Hour Trainer (Wrox Programmer to Programmer) [Paperback]

This is not the only book I bought to learn C#, but after a lot of searching, it's the one I believed could get me "up and running" in minimum time. After a few days with Rod's book and DVD combo, I'm more convinced than ever it's "that good" if you are just getting started with Visual C#. And don't let the title fool you--there is a lot of breadth in the book and sufficient depth to keep you occupied, even while Stephens makes the learning enjoyable.

I'm fairly experienced with the Visual Basic product line (through VB6) and initially intended to move to .NET programming with Visual Basic 2008. Yet, for a number of reasons (mainly to rewrite a commercial application) I decided to learn C# instead. I do not write programs for a living, however, and I'm largely self-taught (OK, one class in college--FORTRAN--which I hated and swore would be the last of my life. It was!).

Rod's book is perfect for me and a lot of others, I believe, who 1.) think learning a language isn't necessarily linear--that is, start at the "beginning" and study each topic in turn until you become fluent and 2.) want to start being productive right away and 3.) don't want to be buried by minutae before understanding basic concepts. He deftly avoids these potential pitfalls quite nicely.

The book is very well organized and cross-referenced which makes study and review very straightforward. Stephens has a great feel for knowing what you need and when, and often anticipates where the questions will come from before you think to ask. Rod explains patiently but compactly--a fluid style that carries through the entire way. He really is a master trainer that teaches "at your desk" versus from a lecturn--and I think you'll like that approach a lot. I certainly do.

Predictably, the book begins by familiarizing you with the programming environment (i.e., the tool you'll use to write programs) but it's an important section and offers solid advice on using the Visual Studio framework. You'll want to refer back to it well after the rest of the book is familiar.

He then explains how to get the "visual" part of your program going--things like using fundamental controls (text boxes, buttons, etc.) and menus. From there, you move on to incorporating calculations and logic--backbones of virtually every program.

The next sections cover Object Oriented Programming (OOP) and do a lot to de-mystify its nature and implementation. Classes are covered in detail with concept descriptions of things like "encapsulation, inheritence, and polymorphism" , amongst others, as well as getting on to the nuts and bolts: properties; methods; raising events; and structures. A host of related ideas are also fleshed out like, collections; arrays; interfaces; overloading plus a whole lot more.

Following that are chapters with popular topics (graphics, databases, LINQ, files, WPF and more) that, while relatively introductory, will still allow you to write non-trivial code. They are largely independently so if there is something you want to find out about, you can easily jump in and out in whatever sequence suits you. Best of all, after completing a chapter, you'll know enough to ask meaningful questions and begin to explore beyond the book if there's something you need to know more about.

Two things really make Stephens' package unique but without a hint of gimmick: the DVD material; and the "Try It" and "Exercise" sections. The DVD, because it's so handy, might tempt you to focus on the videos at the expense of the book, at least to start....

While I think that's 'OK' when you're poking around, once you get serious, you'll realize that the book chapters and the videos go hand-in-hand. I suspect this is particularly true if you're new to programming. Even still, the videos don't cover everything in the book (though, as an aside, there are a few things mentioned in the videos that the book doesn't address.) The videos are well-paced but move right along. Of course, you can watch as often as you like and pause or rewind as needed.

Beyond that, there is simply no substitute for rolling up your sleeves and trying to practice what you've been learning about. The book accommodates that by providing directed study which guides your efforts and provides reasonable challenges. I think you'll find that to be a significant benefit! And how about this--you can email Rod, download source code used in the book and access blogs and forums about C#. The book is really a gateway to a great set of resources!

The only nits I have are small ones...

First, the narrative on the DVDs, while perfectly audible, appears to be the "raw" recording with no post-processing to filter out the occasional background noise. I was a bit surprised by this initially, but soon paid no attention to it.

Second, you might have to play around with your computer monitor's display resolution settings to optimize the video. (I settled on 1024x768 which seemed to work best for me.)

Lastly, and this really can't be considered a nit, Rod's book won't be the last if you want to really dig into all of C#'s nooks and crannies. You'll be able to do a lot with it (really), just not everything. But it will give you a fantastic and reasonably comprehensive start, even if you are new to programming--I'm sure of it.

One final thought--be prepared to highlight, write notes to yourself in the margins, flip-back and forth, review and the rest of the things needed to become a programmer. Some things never change, even if Stephens has made it a whole lot simpler and more fun. Highly, highly recommended!

I'm coming from C++/MFC background and wants to pick up on C#/WPF. I used C# before but not extensively, so I wanted a book to help me review on the Windows Form controls. This book does nicely especially with the videos provided. If you have a background in C# working with console, this book will give you a good introduction to the controls. You will be able to understand the controls and be able to get started immediately. The try-it exercise is a nice plus. You follow the steps by steps guide. Overall, it's a good book if you have some background in C#. Be warn though, if you're totally new to the programming environment and never program before, you will get lost eventhough the book says no previous programming required.

The field of computer programming has changed irrevocably since the days of line-by-line typing. Programming used to involve typing on a novel-length scale, with millennial durations to match. Today, Integrated Development Environments (IDEs) that require dragging, dropping and clicking have arrived. Many of these generate large sections of code to reduce both typing and, possibly, tendonitis. As such, deep knowledge of these tools has become almost as important as knowing the details of the programming language itself. And that's exactly where "Stephens' C# Programming 24-hour trainer" begins. Lesson 1 dives the reader into the IDE headfirst. Many C# books start with Console programming, which resembles old style line by line coding. Not here. This book dives into Windows forms from the get go. Of course, this approach has advantages and disadvantages. Ingrain the word "24-hour trainer" into your mind when purchasing this book. First, this book will take anyone, even a highly caffeinated speed-reader, more than 24 hours to complete. But even if someone with a sponge-like brain were to digest the whole volume in 25 hours, that person would only have a high-level, almost superficial, understanding of the C# language. That said, this book will teach anyone how to create simple windows forms programs in a relatively short time. But some of the more advanced topics receive a mere sprinkling. Still, the concept of starting small applies here as well. This book lays a great foundation for more detailed study. But anyone who wants to program as a vocation will definitely need to move past this book. In that case, the far bulkier, but also far more detailed, "Beginning Visual C# 2010" by Karli Watson, et al, may serve as a better starting point. That book delves into the nuances of the C# language, involves far more typing, and also covers web programming. This 24-hour trainer covers no web programming whatsoever, but a similar book, "ASP.NET 4 24-hour trainer" fills the gap. So be aware that "Stephens' C# Programming" only covers Windows forms programming, or programs designed to work on Windows desktops. Prospective web developers should probably look elsewhere. Regardless, those looking to build desktop applications, and get up to speed quickly, will find this book a perfect starting point. Apart from an overview of the now crucial IDE, this book discusses menus, toolstrips, dialogs, debugging, using variables, arrays, collections, enums and strings. It also introduces decision code such as if, while, and for statements. And of course no C# book can escape the subject of classes and Object Oriented programming (OOP). This book doesn't give a deep explanation of this vast subject, so absolute newcomers may still need reinforcements for complete comprehension. But the discussion remains adequate for the depth of the entire book. Just be aware that OOP has quite a bit more depth to it than presented here. Following a discussion of interaction with the file system, printers, and forms themselves, the final section gives a taste of what's to come. Most modern programs require database connections and data manipulation. That topic deserves a book in itself, so the treatment here merely scratches the surface. One quibble, those using Visual Studio 2010 Express (the free edition) may have trouble finding the "Server Explorer" mentioned in chapter 38. It doesn't exist in this version. Look for the "Database Explorer" instead. Next, the equally large topics of LINQ and WPF receive fly-by attention. Though these sections provide nice introductions, more study on these topics will be required to do anything really interesting with them. Still, as said, these sections introduce the topics very nicely. So go into this book with the right expectations. You will spend more than 24 hours studying it. You will not learn web programming and you will need to study more to accomplish higher-level programming. But everyone starts somewhere, and this book, rife with examples, presents one very good starting point.