Customer Reviews

Accelerated C# 2008

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

 

 

I bought this book last Wednesday and figured it would be a decent enough overview of the new language features. I don't want to downplay the job he does covering new langauge features becuase that coverage is superb, but the job he does covering C# fundamentals is so well done that it eclipses everything else.

So it's a great book for beginners? Well, probably not. I think beginners would benefit by it but it's not a beginners book by any mean. What I do mean is that he does a really in depth job of covering just about every aspect of C# so that he can show the benefits of the new features as well. I've read over 100 books on .NET in the 7 years I've been working with it and frequently the Go to guy when it comes to exception handling for instance. So I really wasn't expecting to learn anything new here. But stylistically, the points he raises in showing how one could elegantly handle a Transaction rollback scenario is just really brilliant. And that same brilliance is exemplified throughout the book.

To that end, the examples in this book are it's real strength. As someone who's written a few books myself, I know how tempting it can be to come up with really simple and overused examples b/c basics aren't much fun to write about. Trey however totally resisted that temptation and I for the life of me can't see a single area that looks like he just 'wanted to get it done'. Everything is seemingly well thought out and written in a way that can clearly make his point clear. He also harkens back to C++ and the fact he has a ton of C++ experience shows through everywhere. It has a feel to it reminiscent of my senior computer science textbooks but without the stuffiness and without coming off as academic. On the contrary, it's the whole aire of advance business scenarios that makes it so cool

Now on to the new language features. I've read several books on LINQ and Lambda expressions. And while they are all great, his explanation of Lambda exprssions and the walk down Functional Programming memory lane is priceless. Had I read this book early on, the nuances of Lambda expressions would have been a lot easier to understand. His coverage of LINQ is in depth as well but he manages to really keep on track and show the business aspects of LINQ without every going down the path of sounding like a 'cool new feature cheerleader'.

I'll admit I have a pretty strong like of Apress books and have a pretty high expectation with their stuff. When I read Faison's Event-Based Programming : Taking Events to the Limit - I found it to be one of the most compelling and well done books I had read in ages. Internally, I thought it would be a longgg time before I came across a book anywhere near that good. Well, all I can really say is that Trey Nash proved me quite wrong. He exceeded any expectation I had by tenfold and got a lot out of this book - not just in C# terms but across the board.

Overall, this is a decent book. But, simply because the author didn't properly define his audience, I have to mark it down a notch. From the 1st sentence of the "About This Book" section in the Introduction (on page xxvi), the author states:

"I assume that you already have a working knowledge of some object-oriented programming language, such as C++, Java, or Visual Basic .NET."

So, I assumed that since I'd already learned C, C++, and Java, but just dabble in programming, I could use this book instead of plowing through another 1200 page book that starts out with a chapter on sequential statements, a chapter on conditional statements, a chapter on iterative statements, etc.. But, that was a faulty assumption. Instead, this book is REALLY designed for programmers who've done some fairly advanced work in other object-oriented languages UNDER THE WINDOWS .NET FRAMEWORK. For instance, at the start of Chapter 1 (page 1, paragraph 1, line 1), it says:

"Since this is a book for experienced object-oriented developers, I assume that you already have some familiarity with the .NET runtime."

And, on page 231:

"I'm assuming that you're already familiar with the nongeneric collection types and collection interfaces available in .NET 1.1--specifically, those defined in the System.Collections and System.Collections.Specialized namespaces."

So, if you're not very familiar with .NET, you'll have problems with the book. Also, the author tends to slip out of even that "advanced .NET programmer" audience in another way: he sometimes writes to programmers who've used previous versions of C#. For instance, when he introduces Delegates in chapter 10, he never really ties them to the C/C++ model of function pointers or Java's inner classes. The closest he comes is saying they implement a callback function.

The author also assumes knowledge of various design patterns from the "Gang of Four's" Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) book (and a few other sources, too). Here are the patterns he references and the pages where he makes those references:

- Abstract Factory: p 451
- Bridge: p 262
- Collection: p 36
- Disposable: pp 3, 19, 106, 187, 189, 374, 376, 377
- Expert: pp 172, 193
- IOU: pp 320, 354, 355, 362
- Monitor: p 337
- Non-Virtual interface (NVI): pp 117, 143, 144, 236, 238, 365, 366
- Observer: p 265
- Singleton: pp 74, 143 285, 377, 381
- Strategy: pp 122, 266, 276, 291
- Template Method: p 366
- Visitor: pp 424, 437

There are also some smaller things that are a bit irritating. First of all, his code formatting is inconsistent. His use of braces ({}) changes constantly. Sometimes he'll start a block with the first "{" immediately following a keyword on the same line. At other times, he'll put it at the start of the next line. Sometimes, he uses both in the same hunk of code. Ditto for his positioning of instance variables (fields in C# terminology). Sometimes he'll have them at the top of the class. Other times, he'll have them at the bottom. Sometimes, both. And, least importantly, he uses too many forward references (especially referring to Chapter 13).

Overall, if you happen to be an advanced programmer who programs in an object-oriented .NET environment for a living and you want to pick up the latest version of C#, this is a very good book. It certainly won't bore you with trivial stuff, and the way the author presents things will be very helpful. But, if you're just a dabbler with limited experience, the book will probably be confusing. As such, I can only rate it an OK 3 stars out of 5. In future printings, if the author merely revises the stated audience to reflect the actuality, and standardizes the formatting of the code, this book would easily be a 4 star book.

The book is appropriately titled as it includes the fundamentals for novices and a fair amount of advanced material to satisfy the intermediate developer. Don't expect to see too many pages devoted to any one topic as this book covers everything from basic C# syntax to Lambda Expressions. For a language book, it was refreshing to see some mention of best practices for once. Just about all of the chapters are sprinkled with advice and tips relating to real-world scenarios.

The book is very readable (which is extremely important to me) and the author did a great job presenting his thoughts in a coherent manner (which is very difficult to do). Again, if you are looking for a detailed reference on the new features in C# 3.0 such as Lambda Expressions or LINQ, you may want to find another book. This book covers those topics, but I believe the primary goal of this book was to give novice and intermediate developers a quick refresher on all of the language features from versions 1.0 - 3.0.

You need to get up to speed with C# 3.0? This is your book.
I have read a lot of books on C# and I was looking for a book that would explain the new features that come with version 3.0 of the language. While other books try to cover the language features and the renewed framework this book just sticks to the language.

For those of you who are new to the C# language this book is a great guide into the language. If you have worked with previous versions of the language and just want an overview of the new specific "3.0" features you might want to skip the first couple of chapters.

Trey Nash, the writer has a strong opinion on what can and should be done. Features can be used but that not justifies as a reason to use it. So next to a good book on the language features it is also full of advice and best practices.
Take for example the chapter on exception handling. This chapter first explains the possibilities followed by the common problems and advice on how to face them.

One thing I didn't like about the book is that there are numerous times the writer compares C++ with C#. That kept me from rating it as a 5 star book. But overall a very good book definitely a reference book to keep close by.

If you are a software developer who has never seen C# or has seen a little of it, and you want to get acquainted with language in a short amount of time, I definitely recommend this book to you. In about 500 pages, Trey begins by mentioning core aspects of the C# language, such as basic syntax, classes, interfaces, explains some stuff every C# developer should have, like generics, structured exception handling, generics, threading, delegates, and finishes the text by showing the new stuff introduced in C# 3.0; extension methods, lambdas and LINQ. Very good book, not boring at any time, great code samples when needed, it will both help you familiarize with the language and get equipped with the knowledge to explore it to its full capacity. Thanx, Trey and Apress!

I'm generally a developer who likes to thumb through a book and keep it on my bookshelf to be readily available. But the free eBook available till June 2008 is a real bonus. It is a searchable PDF that helps you quickly go to sections you want.

The book is spread over 16 chapters and it's about 510 pages, including the index. The book starts off by giving a brief overview about C# and a sample "Hello World" program right away. It then lists out the features that were added in C# 2.0 and the new features in C# 3.0. This I found was good to know as it's sometimes asked on interviews. I was of course looking for the mention of "LINQ" and Nash rightfully describes it as the "Granddaddy" of all the new C# features.

I found the pace of the book quite good, but that might have been because I'm already a C# developer. I liked the beginning of chapter 6 when the author describes about "Overloading Operators" - Just because you can doesn't mean you should! He then goes to explain the sentence and about overloading operators throughout the chapter.

Finally the LINQ chapter which was the last in the book was 29 pages long. Going through the chapter and trying out a few examples, I realized that I now knew LINQ and could code and speak intelligently about it. That's when the title of the book struck me - "Accelerated C# 2008", which is exactly what it was!

This book is a wonderful addition to any bookshelf, especially useful for programmers and developers in any language who want to move to C# relatively quickly.

No doubt, the author is extremely knowledgeable on the intricacies of C# (among other languages), but the beginner or intermediate developer can easily get distracted or lost in author's technical writing style. A re-occurring theme that re-surfaces throughout the book is the comparisons made with C# to C++, and what is going on under the hood, e.g., with the CLR (Common Language Runtime), and the IL (intermediate language) as disassembled from the ILDASM (Intermediate Language Disassembler). While I just want to drive with the C# core language, I find myself analyzing the nuts and bolts of the compiler. There's nothing wrong with this level of detail in and of itself, but it certainly doesn't help accelerate the learning process of C# as the title implies. Not to mention, the lack of exercises to help nail down some of the complex topics into your head. That said - I did enjoy the discussion of when to use containment versus inheritance and certainly agree with the author on his points of view. The book would be best targeted for intermediate/advanced developers with an extensive C++ background and/or for those just looking to reveal hidden technologies underneath the C# language.

This book briefly covers the basics and then shows more advanced ways of applying the basics to the problem at hand. I felt like reading this book was worth my time as I began to understand how a seasoned C# programmer thinks when solving a problem. Trey Nash is trying to impart tidbits of experience he has gained in the trenches of writing complex multi-threaded apps. He brings in a lot of object and pattern theory by showing both the "wrong" and "right" way to do something. This clearly shows the benefits of using patterns and good object theory when constructing applications.

This book is not for beginners.

Author assumes prior knowledge of c++ or java and very often compares, notes the differences of 3.

Easy to read. Chapter 4 is just too long and he mentions himself. it would be nicer to break this chapter into smaller chapters.

Overall, a well written book.

After reading the reviews praising this book, I had high expectations. While the author's prose is clearer than most, it suffers from the usual technical-author-verbosity. I found the overall content of the book lacking, while several sections were very well presented.

The author switches between beginning and intermediate C# topics throughout the text, which can be a bit jarring. For example, he spends about 3 pages introducing delegates before getting into meatier issues. I would have loved a book 1/3rd of this length that skipped intro to intermediate topics.

The author provides constant comparisons and references to how things are done in C++. However, the usefulness of each section rarely exceeds what you can find in MSDN or Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development Series).

There are moments where the author delves into less frequently used features or advanced topics, such as using yield, SafeHandles, or exception neutrality. These are usually presented in an overly complex manner that left me re-reading MSDN or the C# Language Reference more often than not.

There is excellent use of IL to illustrate what's going on behind various language constructs. The chapter on threading is well presented and worth a read.

The best practices embedded in the "Note" subsections can be useful but, again, these ideas are better presented in Effective C# or the various "patterns" pages on MSDN.

Beginners should avoid this book -- this is not an intro text. Intermediate C# developers may want to skim it to ensure they're aware of the latest language features and catch any tips they may not be aware of. Advanced C# developers can probably pass on this book -- you'll likely know all of the content already and the ideas are presented more thoroughly elsewhere.