Reviews (10)

Excellent little .NET introduction
This book delivers exactly what it promises - an excellent overview of essential .NET Framework. Easy to read format, good chapters on IL,Framework,COM+ Interop. Unfortunately very little or no .NET serialization, memory management or threading. But a lot of information for the size of this book. Gives excellent foundation to learn upon.

Nice work.
.NET Framework Essentials will clear away the hype.

.Net Essentials
The .NET Framework edition of publisher O'Reilly® Essentials series is an excellent introduction to Microsoft's new software development framework. This book is suitable for any developer who wants to understand what this new initiative is all about without having to manually strip away the marketing hype. At no point will you come across the phrase "That's the power of .NET" while reading this book. Though the authors are understandably enthusiastic about their chosen subject, their appraisal of the technology is honest, and insightful. However, this is not a how-to book. Most of the practical subjects that are discussed, such as how to create Web Services and Windows Applications using the new .NET SDK, are kept at an intentionally superficial level. This is actually a good thing, since a more in-depth look would detract from the true subject of the book: the .NET architecture, and how it works.

For anyone who has ever developed with Java, .NET is going to seem awfully familiar. Both run on a virtual machines (though not exactly in the same way.) Both provide a garbage collector, thread management, exception handling, and a fully object-oriented programming paradigm. The class structures of their respective SDKs are eerily similar, and even the syntax of Microsoft's newly touted C derivative, C# (pronounced c-sharp), owes a lot to the Java programming language. There are some key differences that differentiate Microsoft's system from Sun's, but as a reader who has coded in Java, I appreciate the fact that the authors often make comparisons between the two. With this approach, Thai and Lam have helped me dismiss my initial suspicion that .NET is really just Java for Windows, and have properly explained why Microsoft's framework is in some ways even more ambitious than Java originally was.

.NET Framework Essentials is nicely broken up into eight chapters, each of which addresses the interests of potential software developers. The first four chapters give an overview of the framework's design goals and discuss software development issues such as how to program for .NET, and how to work with .NET components. The second half of the book deals with the four main services provided by .NET: data processing (ADO.NET and XML), Web Services, Web Forms, and Windows Forms. A chapter is devoted to each, and enough code examples are given to illustrate the concepts that you'll finish each topic with at least a general idea of how to approach a problem in that domain. Again though, this book is an overview, and is not meant to be a reference manual by any means.

One of the strongest points about this book is that it doesn't rely on the reader having access to a copy of Visual Studio.NET. Though it is mentioned several times, all code examples are given with instructions for building using the command-line compilers that come standard with the SDK. This allows readers to download the SDK from Microsoft and try the applications on his or her own computer for free. This book does a very good job of covering the comprehensive tools provided by Microsoft, and could actually be considered a good reference for the command-line arguments of these programs. An appendix is devoted to this very subject, in fact.

There are only a couple of topics that would probably be of interest to experienced developers that I feel were not properly covered in this book. The first is a distinct lack of discussion regarding interoperability between .NET programs and tradition ANSI C++ programs and libraries (or even Windows applications coded using the Win32 API.) .NET is multi-language, but for a language to be part of the club, it needs to conform to .NET's Common Language Specification, which traditional C++ does not do. Microsoft has produced Managed C++ as a possible gateway between the two, but it's not clear at all how well .NET will deal with traditional libraries such as the STL, or even with more specific packages such as OpenGL. This is an issue that should have deserved a few paragraphs in this book, at least.

The second issue I had was that given that .NET relies on a common SDK for all of it's languages, and given that this is a book that covers the essentials of the NET framework, it would be reasonable to assume that the SDK would be one of it's main topics. Unfortunately, that's not the case. Having read the book, I understand why that is so, but I could also see this as being slightly misrepresentative for anyone picking this book up off the shelf expecting a reference book on the .NET SDK.

Editorial Review

Jesse Liberty's Programming C# provides an adept andextremely well conceived guide to the C# language and is written forthe developer with some previous C++, Java, and/or Visual Basicexperience.

It's no secret that many computer books are pretty muchdevoid of an authorial personality. This title is a winning exception.The author is able to weave in clever examples (using such topics ashis own long experience in computing, his dog, Star Trek, etc.)without being coy or getting in the way of presenting real technicalinformation. Liberty's wide experience in computers and general writingskill shows, as he is able to draw on a wealth of examples to move histext forward.

These are a couple of goals at work in ProgrammingC#. First, it's an excellent language tutorial, certainly one ofthe smartest and best available guides to C# as a language. Earlychapters explore basic and obscure language options using inheritance,delegation, interface, and the conventions in C# used to implementthese techniques. The middle part of the book turns toward the .NETFramework itself, with two useful (and somewhat introductory) chapterson both Windows Forms and Web Forms, for standalone and Web-basedapplications, respectively.

Later sections crank up the technicalknowledge again with several advanced topics on understanding .NETassemblies and deployment in detail, as well as "reflection" APIs thatallow .NET programs to essentially modify their code at run time. (Onetechnique, reflection emit, which literally writes bytecodes, willdefinitely interest expert readers, though it's unlikely mostprogrammers will need to do this.) Final sections look at the .NETstream classes (rivaled only by Java's for complexity). Liberty looksat basic file and network I/O as well as how objects get serialized andmarshaled both for SOAP and Web services and "normal" .NETremoting.

The author's sure hand here in navigating the difficultwaters of C# and .NET makes for a relatively concise text that ischock-full of useful information on C#. Filled with notably clever andinventive examples, this book is possibly this veteran computerauthor's best title to date, and it's sure to be a noteworthy resourceas experienced developers tackle C# for the first time. --RichardDragan

Topics covered:

• Introduction to C# and the .NET platform
• A "Hello World" example in C#
• Tutorial to C# as an object-oriented programming language (typesand variables, operators, namespaces, and preprocessor directives)
• Defining classes in C# (including static members, finalizers,overloading, and read-only fields)
• Inheritance and polymorphism implemented in C#
• Operator overloading
• Structures in C#, interfaces, arrays, and indexers
• Built-in .NET collections, strings, and regular expression support
• Structured exception handling
• Delegate and events
• Introduction to programming with Windows Forms
• ADO.NET database APIs (including basic XML support)
• Quick introduction to Web Forms and ASP.NET used with C#
• Introduction to Web services (SOAP, WSDL, and Discover servicesdescribed)
• In-depth guide to .NET assemblies (including metadata, versioning,private and shared assemblies)
• C# support for attributes and reflection (including reflection emittechniques)
• Marshaling and remoting (with and without SOAP)
• Threads and synchronization
• Tutorial to C#/.NET streams (including basic I/O techniques, Webstreams, and serialization)
• COM and .NET interoperability

Reviews (7)

nothing good to say
Wow!!! This book is really badly written. I was impressed by their ASP book as an introductory crash course and it worked because ASP is easy anyway. But C# and object oriented programming seem to be beyond the authors' understanding. Everything is referred to as a box. I have 6 years of OO programming and even I found it difficult to read and understand. It is Repetitive. Based on old beta .NET. Not organized. Topics mixed all over the place. Confusing. Repetitive. Some sentences just stop halfway through. The real world objects they compare to are a joke. The same facts are mentioned over and over again in the same confusing way. Jargon is used and facts are thrown in at random but with no explanations. I wish I had read other people's comments before I bought it. Did I mention it is repetitive?

OK C# learning book
This book is based on the Beta release of C# and is is full of typos, errors, and misprints. The screen shots at the bottom of each page have been reduced to the point where they are hard to read.Since C# is a new programming language, it appears that the authors did not know C# as well as they should have or the publisher was in a hurry to get this book to market. When Visual Studio.Net was in the beta, a lot of companies tried to saturate the market with C#, Visual Basic, ASP, and ADO books. This book is not up to par with the usual Maran Graphics high quality. Your dollars would be be wisely spent elsewhere. I would recommend Robert Oberg's "Introduction to C# using .Net" instead. Hopefully the authors and publisher of this book are working on a "Second edition" to correct the issues. The idea of "virtual blueprint" is good but this book needs to be editted and the bugs removed.

Editorial Review

Aimed at aspiring C# programmers of all levels, legendary Windows expert Charles Petzold's Programming Windows with C# provides an extremely in-depth and intelligent tutorial to the APIs underpinning Microsoft's .NET Framework.

For a generation of programmers, Petzold's Programming Windows: The Definitive Guide to the Win32 API provided a virtual bible on how to get started with Windows development. This massive, handsomely bound hardcover edition attempts the same breadth of coverage for Microsoft's new C# language and the new .NET. With several examples clearly inspired by the earlier C title, this book demonstrates the author's keen eye for showing off and explaining the capabilities of low-level APIs to good effect.

The book first outlines basic "Hello World" examples for both a console and Windows Forms. Next, there's coverage of basic support classes (like points and rectangles) before turning toward using these structures in extensive sections on graphics programming. Petzold's traditional strengths as a computer author are in ample evidence here, with many short examples that exercise the capabilities of the new .NET APIs.

Veteran readers will recognize the basic shape of the early Win32 title in the organization of this (completely rewritten) C# version in the flow of topics from graphics, keyboard, mouse and timers, and the like. (One production note here is that the order of later chapters does jump around somewhat, circling back to graphics topics several times instead of presenting related APIs in order.)

The sections on graphics transforms and how to manipulate images are worthy of note. There's excellent coverage of the possibilities of working with text and fonts output in .NET. Nifty working samples for several types of clocks and shape-drawing demos will let you explore graphical APIs in detail.

Several chapters cover basic Windows Forms control programming with buttons, labels, and edit controls and then splitters, ListView, and TreeView controls. This volume closes out with references to files and streams, and math and string APIs. For any developer who wants to create state-of-the-art, "traditional" client-side software, this book is sure to be required reading for its in-depth look at graphics and other leading-edge .NET features. It proves once again that learning low-level APIs in detail is still a good way to learn Windows programming. --Richard Dragan