□适合对象：C# 程式语言学习者
□内容特色：由知名C++技术专家与作家 Stanley B. Lippman 所着。
Lippman 着有《C++ Primer》，为 C++ 领域之杰出教本。
□制作特色：含 index，网片输出，平装。
□纲要：
416 pages
Now Stan Lippman brings you C# using his famed primer format. C# PRIMER is a comprehensive, example-driven introduction to this new object-oriented programming language.
C# is a cornerstone of Microsoft's new .NET platform. Inheriting many features from both Java and C++, C# is destined to become the high-level programming language of choice for building high-performance Windows and Web applications and components--from XML-based Web services to middle-tier business objects and system-level applications.
First, you will tour the language, looking at built-in features such as the class mechanism, class inheritance, and interface inheritance--all while you build small programs. Next, you will explore the various library domains supported within the .NET class framework. You will also learn how to use the language and class framework to solve problems and build quality programs.
Highlights include:
Adding C# to your toolbox will not only improve your Web-based programming ability, but also increase your productivity. C# PRIMER provides a solid foundation to build upon and a refreshingly unbiased voice on Microsoft's vehicle to effective and efficient Web-based programming.
Table of Contents
Preface.
1. Hello, C.
A First C Program.
Namespaces.
Alternative Forms of the Main Function.
Making a Statement.
Opening a Text File for Read and Write.
Formatting Output.
The string Type.
Local Objects.
A Value and Reference Types.
The C Array.
The new expression.
Garbage Collection.
Dynamic Arrays: The ArrayList Collection Class.
The Unified Type System.
Jagged Arrays.
The Hashtable Container.
Exception Handling.
A Basic Language Handbook.
2. Class Design.
Our First Independent Class.
Opening a New Visual Studio Project.
Declaring Data Members.
Properties.
Indexers.
Member Initialization.
The Class Constructor.
The Implicit this Reference.
static Class Members.
const and readonly Data Members.
The enum Value Type.
The delegate Type.
Function Parameter Semantics.
Function Overloading.
Variable Length Parameter Lists.
Operator Overloading.
Conversion Operators.
The Class Destructor.
The struct Value Type.
3. Object-Oriented Programming.
Object-Oriented Programming Concepts.
Supporting a Polymorphic Query Language.
Designing a Class Hierarchy.
Object Lessons.
Designing an Abstract Base Class.
Declaring an Abstract Base Class.
static Members of an Abstract Base Class.
A Hybrid Abstract Base Class.
Defining a Derived Class.
Overriding the Inherited Virtual Interface.
Overriding the Virtual Object Methods.
Member Access: the new and base Modifiers.
Sealing a Class.
The Exception Class Hierarchy.
4. Interface Inheritance.
Implementing a System Interface: IComparable.
Accessing an Existing Interface.
Defining an Interface.
Explicit Interface Member Implementations.
Inherited Interface Members.
Overloaded, Hidden, or Ambiguous?
Getting Copy Semantics Right: Implementing ICloneable.
Getting Finalize Semantics Right: Implementing IDisposable.
BitVector: Extension through Composition.
5. Exploring the System Namespace.
Supporting the Fundamental Types.
The array is a System.Array.
Querying the Environment.
System.IO.
A System Miscellany.
Regular Expressions.
System.Threading.
The Web Request/Response Model.
System.Net.Sockets.
System.Data (ADO.NET).
System.Xml.
6. Windows Forms Designer.
Our First Windows Forms Program.
Building the GUI.
Implementing the Event Callback Routines.
Inspecting and Generating Control Events.
Implementing the MessageBox Popup Dialog.
The ListBox for Unformatted Output.
Exploring the File Dialog.
A Pocketful of Buttons.
Serving Up Menus.
Brief Exposure: the DataGrid Control.
Adding a PictureBox Control.
7. ASP.NET and Web Forms Designer.
Our First Web Forms Program.
Opening an ASP.NET Web Application Project.
Adding Additional Pages to a Project.
The HyperLink Control: Linking to Other Pages.
The DataGrid Control.
Understanding the Page Event Life Cycle.
The Data Provider.
Web State Management.
Managing State: Class Members.
Managing State: the Session Object.
Managing State: the Application Object.
Validation Controls.
Adding a DropDownList Control.
Adding a Group of RadioButton Controls.
Adding a CheckBox Control.
Adding Validators to a Control.
Adding a Calendar Control.
Adding an Image Control.
Programming Web Server Controls.
8. The Common Language Runtime.
Assemblies.
Runtime Type Reflection.
Modifying the Retrieval through BindingFlags.
Invoking a Method during Runtime.
Delegating the Test to Reflection.
Attributes.
The Intrinsic Conditional Attribute.
The Intrinsic Serializable Attribute.
The Intrinsic Dllimport Attribute.
Implementing Our Own Attribute Class.
Runtime Discovery of Attributes using Reflection.
The Intermediate Language.
Index.
C# is a new language invented at Microsoft and introduced with Visual Studio.NET. More than a million lines of C# code already have gone into the implementation of the .NET class framework. This book covers the C# language and its use in programming the .NET class framework, illustrating application domains such as ASP.NET and XML.
My general strategy in presenting the material is to introduce a programming task and then walk through one or two implementations, introducing language features or aspects of the class framework as they prove useful. The goal is to demonstrate how to use the language and class framework to solve problems rather than simply to list language features and the class framework API.
Learning C# is a two-step process: learning the details of the C# language and then becoming familiar with the .NET class framework. This two-step process is reflected in the organization of this text.
In the first step we walk through the language--both its mechanisms, such as class and interface inheritance and delegates, and its underlying concepts, such as its unified type system, reference versus value types, boxing, and so on. This step is covered in the first four chapters.
The second step is to become familiar with the .NET class framework, in particular with Windows and Web programming and the support for XML. This is the focus of the second half of the book.
Working your way through the text should jump-start your C# programming skills. In addition, you'll become familiar with a good swatch of the .NET class framework. All the program code is available for download at my company's Web site www.objectwrite.com.
Mail can be sent to me directly at slippman@objectwrite.com.
The book is organized into eight relatively long chapters. The first four chapters focus on the C# language, looking at the built-in language features, the class mechanism, class inheritance, and interface inheritance. The second four chapters explore the various library domains supported within the .NET class framework.
Chapter 1 covers the basic language, as well as some of the fundamental classes provided within the class framework. The discussion is driven by the design of a small program. Concepts such as namespaces, exception handling, and the unified type system are introduced.
Chapter 2 covers the fundamentals of building classes. We look at access permission, distinguish between const and readonly members, and cover specialized methods such as indexers and properties. We walk through the different strategies of member initialization, as well as the rules for operator overloading and conversion operators. We look at the delegate type, which serves as a kind of universal pointer to a function.
Chapters 3 and 4 cover, in turn, class and interface inheritance. Class inheritance allows us to define a family of specialized types that override a generic interface, such as an abstract WebRequest base class and a protocol-specific HttpWebRequest subtype. Interface inheritance, on the other hand, allows us to provide a common service or shared attribute for otherwise unrelated types. For example, the IDisposable interface frees resources. Classes holding database connections or window handles are both likely to implement IDisposable, although they are otherwise unrelated.
Chapter 5 provides a wide-ranging tour of the .NET class library. We look at input and output, including file and directory manipulation, regular expressions, sockets and thread programming, the WebRequest and WebResponse class hierarchies, a brief introduction to ADO.NET and establishing database connections, and the use of XML.
Chapters 6 and 7 cover, in turn, drag-and-drop Windows Forms and Web Forms development. Chapter 7 focuses on ASP.NET, and the Web page life cycle. Both chapters provide lots of examples of using the prebuilt controls and attaching event handlers for user interaction.
The final chapter provides a programmer's introduction to the .NET Common Language Runtime. It focuses on assemblies, type reflection, and attributes, and concludes with a brief look at the underlying intermediate language that is the compilation target of all .NET languages.
The book does not assume that you know C++, Visual Basic, or Java. But it does assume that you have programmed in some language. So, for example, I don't assume that you know the exact syntax of the C# foreach loop statement, but I do assume that you know what a loop is. Although I will illustrate how to invoke a function in C#, I assume you know what I mean when I say we "invoke a function." This text does not require previous knowledge of object-oriented programming or of the earlier versions of ASP and ADO.
Some people--some very bright people--argue that under .NET, the programming language is secondary to the underlying Common Language Runtime (CLR) upon which the languages float like the continents on tectonic plates. I don't agree. Language is how we express ourselves, and the choice of one's language affects the design of our programs. The underlying assumption of this book is that C# is the preferred language for .NET programming.
The book is organized into eight relatively long chapters. The first set of four chapters focuses on the C# language, looking at the built-in language features, the class mechanism, class inheritance, and interface inheritance. The second set of four chapters explores the various library domains supported within the .NET class framework, such as regular expressions, threading, sockets, Windows Forms, ASP.NET, and the Common Language Runtime.
Type names, objects, and keywords are set off in Courier font, as in int, a predefined language type; Console, a class defined in the framework; maxCount, an object defined either as a data member or as a local object within a function; and foreach, one of the predefined loop statements. Function names are followed by an empty pair of parentheses, as in WriteLine(). The first introduction of a concept, such as garbage collection or data encapsulation, is highlighted in italics. These conventions are intended to make the text more readable.
The richest documentation that you will be returning to time and again is the Visual Studio.NET documentation. The .NET framework reference is essential to doing any sort of C#/.NET programming.
Another rich source of information about .NET consists of the featured articles and columns in the MSDN Magazine. I'm always impressed by what I find in each issue. You can find it online at http://msdn.microsoft.com/msdnmag.
The DOTNET mailing list sponsored by DevelopMentor is a rich source of information. You can subscribe to it at http://discuss.develop.com.
Anything Jeffrey Richter, Don Box, Aaron Skonnard, or Jeff Prosise writes about .NET (or XML in Aaron's case) should be considered essential reading. Currently, most of their writing has appeared only as articles in MSDN Magazine.Here is the collection of books that I have referenced or found helpful:
Stanley Lippman
Los Angeles
November 18, 2001
www.objectwrite.com