Echo Dot countdown boutiques-francophones Introducing Fire 7 tablet, starting at $59.99 WFM Furniture Kindle Paperwhite Explore the Vinyl LP Records Store sports Tools

Showing 1-6 of 6 reviews(2 star). See all 97 reviews
on April 9, 2002
I beg to differ with most reviewers: the book is not so good to deserve 5 stars, or even 4. I give it 2 stars only because 1) it really is one of few books that focus in C# and doesn't go into a myriad of other .NET topics, and 2) some of the examples are insightful.
However, the book's goals are inconsistent in general. The first chapters give an overview of object-oriented programming, so it seems the book is geared towards beginners, who might not know C and C++. But many examples use language features that were not introduced before, and in some of them the author doesn't even try to explain what are these things and why were they included. Programmers experienced with other OO languages (mainly C++ and Java) will be able to understand, but these readers wouldn't need to read an introductory overview of OO concepts. That's why the book is inconsistent.
Unfortunately, there are more problems: some examples weren't particularly well-thought, and one of them (about user-defined conversions) is nothing short of horrible. Ok, so I may be stupid, but I had to type the code, compile it, and trace its execution step by step to really understand it. And after all this I could not believe what I saw: a Celsius object really stores temperatures in fahrenheit, and only when it is converted to a float through a user-defined conversion is that the numerical value of the temperature is converted to Celsius. The same happens in the Fahrenheit class (which stores temperatures in celsius, in the example). And this conversion to float is only required when the value of the object is to be displayed... talk about "textbook examples". Kids, don't try this at home. It's really terrible, terrible practice in real-world code.
As a last note of discontentment, the book really should not be called "Inside C#". Aside from a few superficial looks at what the compiler is doing by examining disassembles of code, nowhere does the book treat the language in depth. It is more of a "fast overview of C# for people that already know at least C++". One of the many examples of shallowness that I happen to remember now is about method overloading: precise rules for overload resolution are not given anywhere, only hinted about.
Summing up, it is not worthless, but it's far from definitive. Better books on C# will surely appear, as we developers deserve. Right now I recommend "Programming C#" from O'Reilly over this one.
0Comment|Was this review helpful to you? Report abuse
on January 3, 2003
1) Chapters 1 through 11 seem okay, but the rest simply don't make the grade. The chapter on Delegates and Events is too shallow, and some of the claims made by the author are totally incorrect. (for example: "an event delegate must be defined as taking two arguments") Strongly recommend skip this chapter altogether, instead, try reading through online doc, which gives a much better definition and explanation.
2) User-defined conversion example is horrible, the whole section should be better eliminated than confusing the reader.
Bottom line: the authors apparently didn't do their homework well,and just rushed out the book for marketing purposes, so watch out for errors and false statements throughout the book.
0Comment|Was this review helpful to you? Report abuse
on July 25, 2003
I read this book to get an in-depth, inside view of the inside workings of the C# language.
I didn't get that - I got introductory exercises followed by some unstructured detail, all interspersed with irrelevant opinion and off-topic rambling.
The word 'Inside' implies that the book would go into intimate detail about every aspect of the topic (have a look at 'Inside Windows NT' for example) and I feel that this book tried to go into that detail in some places, but not others.
I wouldn't recommend this book because:
1. Too high level; I'd question the inclusion of the 'introduction to Object Oriented programming' sections. The back cover quotes "in-depth architectural information". I don't agree with that.
2. A lot of inaccuracies; I question whether the author really knows the C++ language as his C++ code snippets are often wrong, which is unhelpful when you are migrating from C++ to C#.
3. Many omissions or lack of detail - like controlling Disposable objects' lifetime through the 'using' keyword (an important feature); 'override', 'abstract', 'volatile', 'ref', 'stackalloc' and 'base' keywords.
4. Too much white space, and I found the code samples to be poorly presented - repeating entire files of code just to show a single line changed is a waste of trees.
There are many other books on the subject that are better than this one.
0Comment|Was this review helpful to you? Report abuse
on June 3, 2001
I was looking foreword to getting Inside C# in the mail. I was very disappointed when I started reading it. I bought the book thinking they used the title of one of my all time favorite books “Inside Visual C++” by David Kruglinski. He would be rolling over in his grave if he knew about the contents of this book.
I am a professor who has been teaching programming languages for about two decades. I currently teach advanced concepts in C++, Visual C++ Windows programming, Visual Basic and Java. I am very experienced in assessing books for my students. Inside C# should not be you first introduction to C#. It is worth reading for the insights into the development of the .Net and C#. But it should be the third or forth book you read about C#. Inside C# does not effectively reflect the new emerging .Net technology nor C#.
Tom Archer claims to be a good programmer but his writing skills leave a lot to be desired. The level at with he covers the subject matter ranges from a level so simple it is boring to overly complex concepts leaving the reader with the thought, “what is he say?”
Last comment, the paper quality of the book is so poor that the yellow highlighter and red marking pen bleeds through the page!
0Comment|Was this review helpful to you? Report abuse
on June 14, 2001
In attempting to explain why I disliked this book, I found that there are too many reasons to list. The first being that it doesn't really teach the C# language (instead starting with several chapters that explain why object-oriented programming is important). Second, it doesn't teach Object-oriented programming, since those first few chapter are only about why you'll want to use that programming method. Third, it's not a beginner, intermediate or advanced guide, so who is it really for? Finally, and this is the saddest point, it's the best of the six beta books that I've read so far. So, if only to save others from wasting as much time and money as I have - I'd suggest waiting until a few new books hit the market.
0Comment|Was this review helpful to you? Report abuse
on October 14, 2002
As someone who has developed software for 25 years, including 4 years
with C++ and none with Java, I find some features of this book appealing,
but have the impression that clearer, shorter books must exist that cover
the same material. This nearly 900-page book covers a wide range of C#
topics and is meant to be especially readable for people that know C++
or Java. An appendix describes the assembly-language-like intermediate
language into which C# and other languages are compiled. Examples of C#
code account for a substantial fraction of the book.
Many of the examples show intermediate code into which example C#
code has been translated. Early on, I found these translations and
the appendix useful for getting a feel for the intermediate language.
After a chapter or two, I started skipping over the translated versions.
Eliminating most of these translated versions would make the book
significantly shorter without compromising the discussion.
The book has a chatty writing style that is probably intended to be
friendly. There is nothing inherently wrong with using this idea in
scientific and engineering writing, but this book's presentation comes
across as paternalistic and verbose. For me, the last straw, and the
cause of my writing this review, is a flowery sentence in the chapter
summary on page 212:
"In this way, attributes are like a breath of fresh air -- in one
fell swoop releasing the shackles that have bound developers for so
many years."
Some of the writing is equally painful to read, and distracting. Writing
improvements and better editing could clarify the book and make it, say,
20% shorter. Problems include the excessive and not-quite-correct
use of the words "however" and "although", frequent use of the word
"I" in a book with two authors, and referring to terms that have not
yet been defined. Some of the book's examples are framed in terms of
Microsoft Windows topics; even someone intimately familiar with Windows
might feel that the material to be explained does not require the amount
of text that this book uses to set up its examples.
The book, published by Microsoft Press, refers to the intermediate
language almost exclusively as MSIL, for "Microsoft Intermediate
Language". There is apparently a distinction between MSIL and CIL
("common intermediate language"). The book's index has some two dozen
entries for MSIL, but just one entry for CIL. This entry points to
page 548. The relationship between CIL and MSIL, whatever it is, is
important enough that it needs to be explained in the first few pages,
and indexed! This and similar cases in the book give the impression
that the C# language is a Microsoft product for Microsoft platforms only.
It appears, though, that this is not Microsoft's intent, and that C# is
not evolving in this way. See, for example,, or numerous
articles on the web about the adoption of C# and common language
infrastructure for standards by the European Computer Manufacturers
Association (ECMA).
When reading about something familiar in this book, such as C# concepts
that are similar in C++, I went through the material quickly and skipped
many of the examples; with less-familiar topics, I found myself reading
the material and then seeking clarification elsewhere. It's often nice
for readers to have multiple sources when learning something new, but
in the case of C#, a clearer book can probably be written for the
same audience while presenting less of a need to use multiple sources.
Particularly for experienced developers, using other books to learn C#
should be more efficient than using this one.
0Comment|Was this review helpful to you? Report abuse

Need customer service? Click here