Customer Reviews

Beginning C# 2008: From Novice to Professional (Expert's Voice in .NET)

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

 

 

I almost always read reviews on any book I consider buying, but for whatever reason, I bought this one without reading up on it first. I was at Barnes and Noble, and I really wanted to leave with a book on C#, and the first chapter seemed pretty good, so I went for it.

I'll just get it all out on the table and say that this is the worst instructional book I have ever read. As others have said, he uses constant analogies to try to make things eaiser to understand, but they really just make you even more confused. Also, considering the use of the word "beginning" in the title, you would think this book would be aimed at beginners, and it is not. Frankly, I don't think it's aimed at anybody. It's just an awful book, and you'll find yourself reading chapters numerous times before you understand anything.

I have switched over to APress's "Pro C# 2008 and the .NET Platform", and it is a MUCH better text. Ironically, it covers the basics a lot more in depth than this book does, too. Bottom line: don't even bother with this garbage. I may try to go back after I have a better understanding of C# and reread this book (since I already paid $40 for it...), but I wouldn't lose any sleep tonight if I accidentally set the book on fire after dinner. Accidentally.

After reading some parts, especially the part about inheritance and polymorphism, I have to say that this book is not for beginners, even not for advanced developers. This book leads people to wrong way to design. For example, The Shape, Rectangle and Square relationship is discussed in very complex and abstract way that the readers can't understand even if they read that portion 10 times. The author tried to explain the "good" way of component level development using that example and spend a long time on comparing different approaches. While summarized that all approaches have shortcomings if simple inheritance and polymorphism is used, he suggested using a new way called "component level design". But, believe me, he didn't provide the component level solution for this problem finally and you will be left totally confused. If you check another examples in this book, you will find them very uninteresting and ugly.
Don't buy this book if you want to learn something.

I wish I had read the reviews first. This a terrible book. I am an experienced programmer, and thought the beginning book would be an easy transition into C#, but like the other reviews, the analogies are terrible and the examples are worse. I quit after 200 pages. Don't waste your time.

I will have to agree with the majority of the reviews that this is not a very good book. I have read a couple of other books on C# that I learned a lot from. I am trying to get my hands on as much C# material as I can; I get a little something more out of each book. Now, when I started reading this book (before I read any of these reviews), I began thinking that if I didn't have any previous knowledge of C#, I would really have no idea what this guy was talking about! There is no way that this book is for beginners! It is very, very confusing. I do, however, feel that there are some good concepts in this book, but they are just laid out in a very confusing manner. Sometimes I have to read the same thing 10 times, only to semi-understand it! I was a bit relieved when I read these other reviews just so I knew I wasn't losing my mind! The author might be a good programmer, but he needs to polish up on this writing skills! Sorry!

Don't buy this book. Poor english, terrible analogies, no structure. After reading it for a day I had to stop myself from banging my head against the wall. Christian Gross tries to explain technical concepts with real world analogies such as going through shopping malls, having an instance of your private wallet and publicly exposing your credit card, limiting the public access to charging your account. He then goes on to try explaining "static" methods with a push-to-talk family phone analogy. All his analogies are confusing, and I cannot see how anyone can grasp any of the technical concepts without having a solid background. The problem is, if you have a solid background in programming, then the analogies are useless. If you don't have the background, they are even more useless. Sorry Christian, but you really messed this one up. So did APRESS and the technical reviewer Christian Kenyeres.

I made it through only the first 25% of the book, and I could take no more. This book is really quite bad.

Just a few of the things that make this book so bad: 1) Rambling and EXTREMELY confusing analogies that destroyed any chance of me actually understanding the material. Though I think that the author was trying to draw comparisons to everyday things in order to help a beginner understand the material, he failed miserably. A few simple drawings and basic descriptions of things like memory, stack, heap, etc. would have served the reader much better. 2) Code and terminology are used but never explained. Though I understand that learning a language requires referencing multiple sources, and I do it often, there was simply too much unexplained terminology and too much code that was never explained and was not found anywhere else in the book (e.g. Assert.AreEqual). 3) Typos and mistakes: In the midst of all the confusion caused by the writing style, there are also typos and editing errors that ensure complete confusion. As an example, there are block diagrams in which sections of code are pointed to and explained, but in some cases the wrong portion of code is pointed to for a particular description. I also found incorrect code results that belonged to other examples later in the book. Obviously they copied and pasted without paying enough attention. 4) I could continue, but there is just too much.

I do have one positive comment. I very much appreciate the author's emphasis on testing and code organization. I think it is a valuable subject that is overlooked by many. This is the only reason I gave this book a rating of 2 rather than a 1.

I am totally dumbfounded at Apress. I have the VB version of this book. And from these reviews I can tell both books are similar. Meaning after reading some sections you will be left saying to yourself, "what just happened"?

As several have noted thru the constant use of analogies, the author takes you far down a beaten path that is typically very far from where you want to be. You end up trying to think exactly like him to try to understand what his analogy is trying to explain. Very bad writing style.

The examples he does use to try to demonstrate programming principles are bad also. I have been working in Java for sometime. So I have an understanding of Interfaces vs. Inheritance. With a good understanding of this particular topic, I found myself very confused reading some of his chapters that try to discuss Object Oriented principles.

If you check some of the other books this author has written you will see a general overall rating of 3 at best due to his poor writing style.

I used to heavily recommend any Apress book on any given topic. Seeing as Apress is coming out with a 2nd edition of this throwaway book, I can no longer abide by that. Will never buy an Apress book until I've had a chance to read some samples in a bookstore, or read several reviews.

I have to say it is hard to imagine how to get most of the codes mentioned in this book to work. For example Calculator (The beginning of the book). This is Dll file of Calculator operations:
namespace Calculator
{
public class CalculatorClass
{
public static int Add(int number1, int number2)
{

return number1 + number2;
}
}
}

And then it shows how to test application with Non user inputed numbers.
OK, but how do we make it work in real life when we need to use users numbers rather than numbers we selected. No word about it. In console applications brackets it won't accept Number1 and number2 directly,(I couldnt not figure it out)So the way I did it, is:


namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Adding two numbers");

Console.Write("Please enter 1st number: ");
string SNum1 = Console.ReadLine();

Console.Write("Please enter 2nd number: ");
string SNum2 = Console.ReadLine();

int num1 = int.Parse(SNum1);
int num2 = int.Parse(SNum2);

int total = Calculator.CalculatorClass.Add(num1, num2);


Console.WriteLine("Total is: " +total);
Console.ReadLine();
}
}
}
It's working, but is this the way it meant to be? Maybe I am just to stupid for this book.

Beginning C# 2008 From Novice to Professional by Christian Gross is a good choice to learn C# for any programmer with no or less .NET background. The way the book is organized is excellent and the very good part is, it has lot of samples with description. This book gives a diligent exposure to Types, Exception handling, OOP basics, .NET generics and Multi threading.My personal opinion on the harder part of this book is, the analogies used, which are confusing and sometimes I have to read it twice or thrice to understand the idea behind the analogy.

Overall, it's a good book for any beginner in C#.

Originally I actually found some of the analogies quite useful which led me to persevere with the rest of the book. But it really wasn't worth it. After reading about delegates elsewhere & having an ok understanding of them I could not believe the way this author introduced them. He dives straight into complex examples without properly introducing the topic. Some of the language used in the book is really confusing, and concepts are explained badly. No way is this book for beginners, I cannot imagine someone would understand any of this book without a prior understanding of programming.