C# Essentials

C# Essentials

Paperback(Second Edition)

View All Available Formats & Editions
Choose Expedited Shipping at checkout for guaranteed delivery by Wednesday, December 19

Product Details

ISBN-13: 9780596003159
Publisher: O'Reilly Media, Incorporated
Publication date: 02/28/2002
Edition description: Second Edition
Pages: 218
Product dimensions: 6.00(w) x 9.00(h) x 0.53(d)

About the Author

Ben Albahari is cofounder of Genamics, a provider of tools for C# and J++ programmers, as well as software for DNA and protein sequence analysis. He is author of A Comparative Overview of C#, a frequently cited comparison of C# with C/C++ and Java that was recently named by DevX as one of the top 10 .NET sites. Ben is a resident of Perth, Australia, and in his spare time enjoys composing music on his computer. He can be reached at ben@genamics.com.

Peter Drayton is an independent consultant, helping early-stage companies define and build systems that take advantage of technologies such as .NET, SOAP, XML, and COM+. Peter is also an instructor for DevelopMentor, where he teaches Essential C#.NET. Originally from Cape Town, South Africa, Peter now lives in the San Francisco Bay Area with his wife, Julie. He spends his spare time researching .NET and tinkering with a small flotilla of computers cluttering up their a partment. He can be reached at peter@razorsoft.com.

Brad Merrill works as a software engineer in the .NET Framework Integration team at Microsoft. He previously worked as a software engineer at Digital Equipment Corporation and Sybase. His areas of expertise are in distributed systems, transaction processing, operating systems, and compiler technology. Brad lives in Redmond, Washington, and is an avid tournament chess player and bridge player. He can be reached at zbrad@gte.net or http://www.cybercom.net/~zbrad.

Read an Excerpt

Chapter 1: Introduction

C# is a language built specifically to program the new Microsoft .NET Framework. The .NET Framework consists of a runtime environment called the Common Language Runtime (CLR), and a set of base class libraries, which provide a rich development platform that can be exploited by a variety of languages and tools.

C# Language

Programming languages have strengths in different areas. Some languages are powerful but can be bug-prone and difficult to work with, while others are simpler but can be limiting in terms of functionality or performance. C# is a new language designed to provide an optimum blend of simplicity, expressiveness, and performance.

Many features of C# were designed in response to the strengths and weaknesses of other languages, particularly Java and C++. The C# language specification was written by Anders Hejlsberg and Scott Wiltamuth. Anders Hejlsberg is famous in the programming world for creating the Turbo Pascal compiler and leading the team that designed Delphi.

Key features of the C# language include the following:

Component orientation
An excellent way to manage complexity in a program is to subdivide it into several interacting components, some of which can be used in multiple scenarios. C# has been designed to make component building easy and provides component-oriented language constructs such as properties, events, and declarative constructs called attributes.

One-stop coding

Everything pertaining to a declaration in C# is localized to the declaration itself, rather than being spread across several source files or several places within a source file. Types do not require additional declarations in separate header or Interface Definition Language (IDL) files, a property's get/set methods are logically grouped, documentation is embedded directly in a declaration, etc. Furthermore, because declaration order is irrelevant types don't require a separate stub declaration to be used by another type.


C# provides features such as explicit interface implementations, hiding inherited members, and read-only modifiers, which help new versions of a component work with older components that depend on it.

Safe type system

C# is type-safe, which ensures that a variable can be accessed only through the type associated with that variable. This encapsulation encourages good programming design and eliminates potential bugs or security breaches by making it impossible for one variable to inadvertently or maliciously overwrite another.

All C# types (including primitive types) derive from a single base type, providing a unified type system. This means all types--structs, interfaces, delegates, enums, and arrays--share the same basic functionality, such as the ability to be converted to a string, serialized, or stored in a collection.

Automatic memory management

C# relies on a runtime that performs automatic memory management. This frees programmers from disposing objects, which eliminates problems such as dangling pointers, memory leaks, and coping with circular references.

However, C# does not eliminate pointers: it merely makes them unnecessary for most programming tasks. For performance-critical hotspots and interoperability, pointers may be used, but they are only permitted in unsafe blocks that require a high security permission to execute.

Leveraging of the CLR

A big advantage of C# over other languages, particularly traditionally compiled languages such as C++, is its close fit with the .NET CLR. Many aspects of C# alias the CLR, especially its type system, memory-management model, and exception-handling mechanism.

Common Language Runtime

Of fundamental importance to the .NET framework is the fact that programs are executed within a managed execution environment provided by the Common Language Runtime. The CLR greatly improves runtime interactivity between programs, portability, security, development simplicity, cross-language integration, and provides an excellent foundation for a rich set of class libraries.

Absolutely key to these benefits is the way .NET programs are compiled. Each language targeting .NET compiles source code and produces metadata and Microsoft Intermediate Language (MSIL) code. Metadata includes a complete specification for a program including all its types, apart from the actual implementation of each function. These implementations are stored as MSIL, which is machine-independent code that describes the instructions of a program. The CLR uses this "blueprint" to bring a .NET program to life at runtime, providing services far beyond what is possible with the traditional approach--compiling code directly to assembly language.

Key features of the CLR include the following:

Runtime interactivity
Programs can richly interact with each other at runtime through their metadata. A program can search for new types at runtime, then instantiate and invoke methods on those types.


Programs can be run without recompiling on any operating system and processor combination that supports the CLR. A key element of this platform independence is the runtime's JIT ( Just-In-Time Compiler), which compiles the MSIL code it is fed to native code that runs on the underlying platform.


Security considerations permeate the design of the .NET Framework. Key to making this possible is CLR's ability to analyze MSIL instructions as being safe or unsafe.

Simplified deployment

An assembly is a completely self-describing package that contains all the metadata and MSIL of a program. Deployment can be as easy as copying the assembly to the client computer.


An assembly can function properly with new versions of assemblies it depends on without recompilation. Key to making this possible is the ability to resolve all type references though metadata.

Simplified development

The CLR provides many features that greatly simplify development, including services such as garbage collection, exception handling, debugging, and profiling.

Cross language integration

The Common Type System (CTS) of the CLR defines the types that can be expressed in metadata and MSIL and the possible operations that can be performed on those types. The CTS is broad enough to support many different languages, including Microsoft languages, such as C#, VB.NET, and VC.NET, and such third party languages as COBOL, Eiffel, Haskell, Mercury, ML, Oberon, Perl, Python, Smalltalk, and Scheme.

The Common Language Specification (CLS) defines a subset of the CTS, which provides a common standard that enables .NET languages to share and extend each other's libraries. For instance, an Eiffel programmer can create a class that derives from a C# class and override its virtual methods.

Interoperability with legacy code

The CLR provides interoperation with the vast base of existing software written in COM and C. .NET types can be exposed as COM types, and COM types can be imported as .NET types. In addition, the CLR provides PInvoke, which is a mechanism that enables C functions, structs, and callbacks to be easily used from within in a .NET program.

Base Class Libraries

The .NET Framework provides the Base Class Libraries (BCL), which can be used by all languages. These libraries range from those that are a portal to core functionality of the runtime, such as threading and runtime manipulation of types (reflection), to libraries that provide high-level functionality, such as data access, rich client support, and web services (whereby code can even be embedded in a web page). C# has almost no built-in libraries; it uses the BCL instead.

A Minimal C# Program

A minimal C# program is implemented like this:

class Test {
   static void Main(  ) {
      System.Console.WriteLine("Welcome to C#!");

All C# statements are scoped to methods (or special forms of methods), and all methods are scoped to types, such as the class Test. The Main method is recognized as the default entry point of execution, static means the method is an ordinary procedure that does not require an instance of Test to execute, and void means the method does not return a value. System is a namespace containing many related types, one of which is Console. Console is the class that encapsulates standard input/output functionality and has many methods including WriteLine. The brackets, braces, and semicolons are necessary to group and state things unambiguously, and the indentation is there for readability.

To compile this program into an executable, paste it into a text file, save it as Test.cs, then type cs Test.cs in the command prompt. This compiles the program into an executable called Test.exe....

Table of Contents

About This Book;
C# Online;
Conventions Used in This Book;
How to Contact Us;
Chapter 1: Introduction;
1.1 C# Language;
1.2 Common Language Runtime;
1.3 Framework Class Library;
1.4 A First C# Program;
Chapter 2: C# Language Reference;
2.1 Identifiers;
2.2 Types;
2.3 Variables;
2.4 Expressions and Operators;
2.5 Statements;
2.6 Organizing Types;
2.7 Inheritance;
2.8 Access Modifiers;
2.9 Classes and Structs;
2.10 Interfaces;
2.11 Arrays;
2.12 Enums;
2.13 Delegates;
2.14 Events;
2.15 try Statements and Exceptions;
2.16 Attributes;
2.17 Unsafe Code and Pointers;
2.18 Preprocessor Directives;
2.19 XML Documentation;
Chapter 3: Programming the.NET Framework;
3.1 Common Types;
3.2 Math;
3.3 Strings;
3.4 Collections;
3.5 Regular Expressions;
3.6 Input/Output;
3.7 Networking;
3.8 Threading;
3.9 Assemblies;
3.10 Reflection;
3.11 Custom Attributes;
3.12 Automatic Memory Management;
3.13 Interop with Native DLLs;
3.14 Interop with COM;
Chapter 4: Framework Class Library Overview;
4.1 Core Types;
4.2 Text;
4.3 Collections;
4.4 Streams and I/O;
4.5 Networking;
4.6 Threading;
4.7 Security;
4.8 Reflection and Metadata;
4.9 Assemblies;
4.10 Serialization;
4.11 Remoting;
4.12 Web Services;
4.13 Data Access;
4.14 XML;
4.15 Graphics;
4.16 Rich Client Applications;
4.17 Web-Based Applications;
4.18 Globalization;
4.19 Configuration;
4.20 Advanced Component Services;
4.21 Diagnostics and Debugging;
4.22 Interoperating with Unmanaged Code;
4.23 Compiler and Tool Support;
4.24 Runtime Facilities;
4.25 Native OS Facilities;
4.26 Undocumented Types;
Chapter 5: Essential .NET Tools;
C# Keywords;
Regular Expressions;
Format Specifiers;
Picture Format Specifiers;
DateTime Format Specifiers;
Data Marshaling;
Working with Assemblies;
Building Shareable Assemblies;
Managing the Global Assembly Cache;
Using nmake;
Namespaces and Assemblies;

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews

C# Essentials 4.3 out of 5 based on 0 ratings. 3 reviews.
Guest More than 1 year ago
This book definitely explains the essentials and theory behind C#, but like the title, it offers little else. One thing I really appreciate in a programming book is a good practical example that is applicable to a real world situation or problem. The authors' tone is extremely theory centric. This book is thin and fast reading if you need to get up to speed fast on C#, but it is also very thin on examples. I would not recommend this title to anyone who does not have some good experience working with Java, C++ or another strongly typed, object oriented language. If you are a web developer you will definitely want to pick up something like 'Building Web Solutions with ASP.net and ADO.net' by Microsoft Press which places more emphasis on web forms and such. I recently bought 'C# in a Nutshell' as well, so I will post my review when I have finished it.
Guest More than 1 year ago
This book was a great help for me, an experienced programmer, in getting jump-started in C#. It is not intended to be a deep, thorough discussion, but it does give, in a condensed format, a synopsis of the language, and some key fundamentals of the .NET framework. Should be the first book you turn to for C# advice.
Anonymous More than 1 year ago