Customer Reviews

Inside C# (Microsoft Programming)

5 star:		(59)
4 star:		(15)
3 star:		(9)
2 star:		(6)
1 star:		(2)

 

 

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.

If you want an easy to read introductory book on C#, this is probably the best so far. If you want to learn how to build real world apps, look elsewhere, as this book does not cover the .NET Framework classes.

This bears repeating: This book focuses on C# and not the .NET Framework classes. It is useful for learning C#, but it is not useful for learning how to build business apps. As all of your data access is folded up into the .NET Framework classes, you will not learn data access from this book.

While most of the code is simple enough to work under beta 2, the book was written using beta 1. I have yet to run into code that blows up (technical term ;->) under b2, but it is possible. Since it does not cover the Framework, it is probably safe.

The strong part of the book is the breakdown of both beginning and intermediate concepts and the plethora of code samples (have to install from the CD to use). Each concept has at least one sample, and some concepts have many more, each building on the first.

I have to rate this book as average, as it does not quite measure up completely to the cover copy. I kicked it up one star (to four) as it is an Inside book, which are typically aimed towards the developer/user that is just starting out in a technology. I would have knocked off stars if the code would not compile under b2, as it comes out in the next few weeks. Since it covers the language more than the Framework, this is not an issue.

I am sure there are those who think this rating is a bit high, but let me explain. If you are advanced, or have played with C#, this book is not for you. As it is not aimed for the advanced market, per se, I cannot fault the book for what it is.

Conclusion: If you want to learn the C# language and syntax, this is not a bad book. As it does not touch the .NET Framework classes, it will not be completely obsolete in a month, as will large sections of every other C# book. If you are interested in learning more about the Framework classes, and building real world apps, I would wait until the next round of books come out. Those in the next couple of months will most likely either be rushed or error ridden, so watch the reviews before buying.

Unless you're just not paying attention, Microsoft .NET is poised to become the biggest thing to hit software development since the introduction of the Win32 SDK. At the forefront of this effort is a new language called C# (pronounced c sharp) - a hybrid of C++ and Java with the simplicity of Visual Basic.

Unfortunately, until now all of the first books on C# have really been little more than superficial coverages of the language's syntax where the authors spend little to no time detailing why and when one would want to use the different aspects of C#. What I wanted was a book that not only tells me how to use something (they have on-line help for that), but explains the concepts behind the feature's existence.

Now there is such a book: Tom Archer's Inside C#. Archer, who runs the CodeGuru Web site and writes the popular C#/.NET Web newsletter, offers the most complete tutorial on using this new and powerful language.

The first section of the book is an overview section aimed at the programmer new to object-oriented and .NET development. This section includes chapters on .NET and the CLR and provides a clear and concise explanation of how it all ties together. Once that is done, he then has a chapter devoted to writing and compiling your first C# application to make sure that your environment is set up properly.

From there, the second part dives into writing applications. Here you learn all the fundamentals of C# including its interaction with the .NET Common Type System, value types, reference types and the concept of boxing and unboxing. He then goes on to show how to define classes and struct and write applications using the basics of arrays, enums, properties and indexers. Archer finishes up this foray into the fundamentals of C# by explaining how you can extend the C# language with attributes and how interfaces enable COM-like interface-based programming in C#.

In the third section (Writing Code), Archer then covers the topics of expressions, operators, the controlling of program flow and exception handling. In addition, advanced topics such as operator overloading and the use of delegates in writing event handlers is covered.

Finally, the last section (Advanced C#) is easily my favorite. This section includes some of the best information I could find anywhere on such subject matter as multi-threaded programming, reflection and versioning. The Interoperating with Unmanaged Code chapter alone covers how to use COM components from C#, how to write "unsafe", or unmanaged code and how to use Win32 DLLs from C#.

Having read several of the C# books currently available (Eric Gunnerson's A Programmer's Introduction to C# and Ben Albahari's C# Essentials) I have to say that I was quite pleased that Archer didn't take the easy route in simply telling me how to use a given language construct - but instead took the time to fully explain when and why I would want to use it.

I purchased this book after reading Mr. Archer's Visual C++.NET Bible and am extremely happy with it. I have quite a few C# books and can say without hesitation that this book, Jesse Liberty's and Petzold's SECOND C# book are the only C# books worth owning. You buy those three and you'll be set. I personally use them as follows:

* Jesse Liberty - Better than Archer in terms of tutorial style writing. Use this book as your first C# book
* Tom Archer - Awesome reference material and low-level details of the language. Use this book as a reference after finishing Liberty's book
* Charles Petzold - Great for learning how to write Windows apps with C# - once you've learned the language with Archer & Liberty.

Well I heard that C# was supposed to be the new hot thing, so i decided to buy a few books about it.

But after reading 1/2 this book in a day I can tell you one thing, don't buy this book!

The first 1/2 of the book it just talks about the .net and gives hardly any code.

Finally on chapter five it starts talking about classes, interfaces and all that good stuff. But his examples are so short and dumb.

Finally on chapter 10 he talks about the expressions and operators and how to use the loops. To me it makes no sense why he started talking about OOP stuff before he covered the basics on how to do loops and expersions.

Finally at the end there is some other stuff that i haven't read yet ;-0.

But in general I thought his examples were crappy, and short. With the book there is a cd rom that contains all the files and examples he made, and it only adds up to about 1.2 megs!

The last programming book I bought was Programming Windows with MFC and the author had great examples.

My advice is to to find another book if you want to learn how to program c#

For the first time in a long time I sat down and actually enjoyed learning from a technical book! How many times have we purchased a book only to be driven to bed by some wannabe's author's feeble attempts at humor and wit? However, a book written by someone that has a good writing style wouldn't do me much good (or you for that matter if you're looking at this book) if it didn't also "cut the mustard" on the technical side. Believe me, I've read every single C# book on the market and this is BY FAR the best of the lot.

PROS: Great introduction to the type system, classes, operators and operator overloading. Also, major kudos for including several .net chapters on multithreading, reflection and com interoperability.

CONS: Would like to have seen a better opening chapter on oop. Would also like to see more .net stuff - especially winforms. However, since the book's focus is C#, I really couldn't take off for that omission.

Anyway, in final, a really well done book and one that I will keep handy for a good while to come.

If Amazon.com had an MVP award (Most Valuable Purchaser) I'd have it. I spend a lot of time and money purchasing only the best technology books. Now with that said, let me tell you about "Inside C#."

It's, hands down, the best book I've read. Right off the bat Archer explains the fundamentals of OOP, (a chapter all of us should read no matter what kind of OOP geniuses we think we are). He then goes into introducing .NET and never looks back. From C# Class Fundamentals to Writing Code and on to Advanced C#, he keeps you going and motivated to learn. I've gone through the book twice now and have it 'dog eared', marked, scribbled in and flagged.

The author knows his stuff and it shows. Archer is an intelligent well-spoken author that gets the point across no matter what level of experience the reader has. All through the book he explains and re-explains what he's trying to say, (just in case you missed it the first time). Very few authors do this and needless to say it leaves many of us wondering what the heck their point was.

In short, don't get left behind...."GET THE BOOK!!"

Having been bitten before by the hype of a Miscrosoft Press book, I was a little worried when this book finally arrived. However, I can honestly say that this book met and even exceeded my expectations. It is by far the best beginner level book on learning C# on the market. I would like to have seen a bit more .net class stuff, however I didn't take off for that on my ranking because the book's focus is C# and not .net. Having said that, the book does contain a couple of the absolutely best chapters on the .net topics of multithreading and com interoperability available. With regards to the C# language, the book took its time in presenting subject matter without being overly verbose or condescending. I especially liked the fact that as one reviewer said, each topic had at least one demo to further explain what the author was saying and many topics had multiple demos - each building on the previous. I definite good buy in my opinion.

If you're only going to buy one C# book, make this the one. While other books are good, this one is better. The material is covered in a professional manner, but what's more important is the way the author gives real-world explanations for everything. He goes beyond the obvious to give make it real and relate it to everyday development.

Of special interest to me were the chapters on delegates and multithreaded programming. What the heck are delegates anyway? Read the book and find out--the explanation is great. Multithreaded programming is important for many situations. This chapter rates high because you can read it and immediately do it, not then have to figure out stuff that wasn't mentioned.

My copy is now dog-eared, I read it almost every day as I myself become competent in C#

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, go-mono.com, 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.