.NET入门精要：Charles Petzold的.NET Book Zero解析

需积分: 9 140 浏览量更新于2024-07-23 收藏 1.22MB PDF 举报

".NET Book Zero 是一本由 Charles Petzold 撰写的关于 C# 和 .NET Framework 的入门书籍，适合已经熟悉 C++ 的程序员阅读。本书旨在介绍 .NET 平台的基础知识，并帮助读者理解从 C++ 迁移到 C# 和 .NET Framework 需要知道的关键概念。在第一章《Why This Book?》中，作者解释了编写这本书的目的，主要是为了帮助有经验的 C++ 开发者快速适应 .NET 环境，理解新平台的优势和工作方式。第二章《Why .NET?》介绍了 .NET Framework 的优点和核心特性，包括跨语言互操作性、垃圾回收机制以及统一的类库等。第三章《Runtimes and SDKs》讲述了 .NET 的运行时环境（CLR，Common Language Runtime）和软件开发工具包（SDK），以及如何利用它们进行开发。第四章《Edit, Compile, Run, Disassemble》介绍了开发流程，包括代码编辑、编译、运行和反汇编，让读者了解 .NET 应用程序的生命周期。第五章《Strings and the Console》讲解了字符串处理和控制台交互的基本方法，这是所有编程语言中最基础的部分。第六章《Primitive Data Types》涵盖了 .NET 中的基本数据类型，如整型、浮点型、字符和布尔值等。第七章《Operators and Expressions》讨论了运算符和表达式，这是构建程序逻辑的基础。第八章《Selection and Iteration》介绍了条件语句和循环结构，是控制程序流程的关键。第九章《The Stack and the Heap》深入讨论内存管理，解释了栈和堆的区别以及对象的分配方式。第十章《Arrays》讲解了数组的概念和使用，包括一维和多维数组。第十一章《Methods and Fields》介绍了方法和字段，是面向对象编程的核心元素。第十二章《Exception Handling》讲述了异常处理机制，如何捕获和处理运行时错误。第十三章《Classes, Structures, and Objects》深入讨论类、结构和对象，这是面向对象编程的基础。第十四章《Instance Methods》探讨了实例方法，包括访问修饰符、参数传递等。第十五章《Constructors》讲解了构造函数，用于对象初始化。第十六章《Concepts of Equality》介绍了相等性的概念，包括引用相等和值相等。第十七章《Fields and Properties》区分了字段和属性的使用场景。第十八章《Inheritance》探讨了继承，是面向对象设计的重要特性。第十九章《Virtuality》讲解了虚拟性，包括虚方法和重写。第二十章《Operator Overloading》介绍了运算符重载，允许自定义运算符的行为。第二十一章《Interfaces》讨论了接口，作为实现多继承的一种方式。第二十二章《Interoperability》讲述了 .NET 与非托管代码的交互，如 COM 互操作。第二十三章《Dates and Times》讲解了日期和时间的处理，包括日期运算和时区转换。第二十四章《Events and Delegates》介绍了事件和委托，是事件驱动编程的关键。第二十五章《Files and Streams》涵盖了文件和流的操作，如读写文件和网络通信。第二十六章...（章节内容未完整显示）这本书全面地覆盖了从基础到进阶的 .NET 开发知识，对于希望深入学习 .NET 平台的开发者来说是一份宝贵的资源。"

.NET Book Zero Charles Petzold

Version 1.1 Page 15

At the top are a few single-line comments beginning with the familiar

double slashes. C# also supports multi-line or partial-line comments

delimited by /* and */.

All code in a C# program must be in either a class or a structure. This

particular program defines a class (denoted by the keyword class) named

FirstProgram:

class FirstProgram

{

// contents of the class

}

Curly brackets delimit the contents of the class. You can change that

class to a structure using the keyword struct:

struct FirstProgram

{

// contents of the structure

}

The program will compile and run the same.

It is common to define the class or structure with the public keyword:

public class FirstProgram

{

// contents of the class

}

However, using the public keyword with a class is not generally required

in program code. (There are some cases where it is required.) The public

keyword applied to a class is generally found much more in code that

contributes to dynamic link libraries.

When creating this project in Visual Studio, I‘ve used a project name that

is the same as the C# file name, which is the same as the name of the

class defined in that file. None of these name matches is required. In

fact, a C# file can contain multiple class definitions, none of which match

the file name. A class can also be split between multiple files, none of

whose names need match the class name. None of these names need to

be the same as the project name.

Just to avoid confusion, I generally like to restrict my C# source code

files to just a single class and structure, and to use a file name that

matches the class or structure name. (But I sometimes break this rule in

this book.)

In the FirstProgram class (or structure) is a single method named Main.

The entry point to a C# program is always a method named Main, and it

must have an initial capital. C# is a case-sensitive language.

The Main method is defined with the public and static keywords:

.NET Book Zero Charles Petzold

Version 1.1 Page 16

public static void Main()

{

// contents of the method

}

The public keyword indicates that the method is visible from outside the

class in which it is defined. The public keyword is not actually required

for the Main method, and the program will compile and run fine without

it. Sometimes I use public with Main and sometimes not. It‘s a mystery.

The static keyword means that this method is associated with the class

itself rather than an instance of that class. A class is basically an ice

cream dispenser, and instances of the class are sundaes. Unfortunately,

this simple program isn‘t making any sundaes. There is no instance

keyword, however, because static methods are generally the exception

rather than the rule. The world has many more sundaes than ice cream

dispensers, and generally sundaes are more interesting.

This particular Main method has no parameters — indicated by the

empty parentheses following Main—and doesn‘t return anything to the

caller, indicated by the keyword void. (You can also define Main to have a

parameter that is an array of text strings, which are set to the command-

line arguments of the program. Main can also return an integer as a

termination code. See the C# Language Specification, §3.1 for details.)

The body of a method is delimited by curly brackets. The entire body of

this Main method is the statement:

System.Console.WriteLine("Hello, Microsoft .NET Framework!");

As in C and C++, statements in C# are terminated by semicolons. This

statement is a method call. The argument is a string literal enclosed in

double-quotation marks. String literals in C# are restricted to a single

line. In other words, the two quotation marks delimiting the string must

appear on the same line. (If you need to break up a long string on mul-

tiple lines, you can concatenate multiple string literals using the plus

operator, as I‘ll demonstrate in the next chapter.)

Although string literals must appear on one line, C# can otherwise be

freely formatted. This is allowed:

class

FirstProgram

{

public

static

void

Main

(

)

{

System

.NET Book Zero Charles Petzold

Version 1.1 Page 17

Console

WriteLine

(

"Hello, Microsoft .NET Framework!"

)

;

}

So is this:

class FirstProgram{public static void Main(

){System.Console.WriteLine("Hello, Microsoft .NET Framework!");}}

If you code like this, however, nobody will be your friend.

FirstProgram doesn‘t do much except make a call to a method named

System.Console.WriteLine. That‘s a fully-qualified method name. Like

romance novelists, methods in the .NET Framework generally have three

names:

o System is a namespace.

o Console is a class in that namespace.

o WriteLine is a method in that class.

In the .NET class documentation you‘ll find that the Console class

actually has many methods named WriteLine. These various versions of

the WriteLine method are known as overloads. The one I‘m using in this

particular program is defined like so (eliminating line breaks provided in

the documentation):

public static void WriteLine(string value)

There‘s that keyword static again, and what it means here is that Write-

Line is a method associated with the Console class rather than an

instance of the Console class. The static keyword means the method

must be referenced by prefacing it with the name of the class in which

it‘s defined, separated by a period. The class is prefaced with the name-

space in which the class is defined, also separated with a period.

Where is the code for System.Console.WriteLine. which is the code that

actually puts the text on the console? If you look at the first page of the

documentation for the Console class, you‘ll see near the top the following:

Assembly: mscorlib (in mscorlib.dll)

This indicates that the code for the Console class is located in an assem-

bly named mscorlib. An assembly can consist of multiple files, but in this

case it‘s only one file, which is the dynamic link library mscorlib.dll. The

mscorlib.dll file is very important in .NET. The file name at one time

stood for ―Microsoft Common Object Runtime Library‖ but now it stands

for ―Multilanguage Standard Common Object Runtime Library.‖ This is

.NET Book Zero Charles Petzold

Version 1.1 Page 18

the main DLL for class libraries in .NET, and it contains all the basic

.NET classes and structures.

As you know, when you compile a C or C++ program, you generally need

an #include directive at the top that references a header file. The include

file provides function prototypes to the compiler.

The C# compiler does not need header files. During compilation, the C#

compiler access the mscorlib.dll file directly and obtains information

from metadata in that file concerning all the classes and other types

defined therein. The C# compiler is able to establish that mscorlib.dll

does indeed contain a class named Console in a namespace named

System with a method named WriteLine that accepts a single argument of

type string. The C# compiler can determine that the WriteLine call is

valid, and the compiler establishes a reference to the mscorlib assembly

in the executable.

Intellisense also works by referencing mscorlib.dll and getting informa-

tion from the DLL about the namespaces, types, and members.

As you probably know, compiling a C or C++ program is just the first

step in creating an executable. You must then (either explicitly or im-

plicitly) run a linker that accesses library files. Traditionally, code in the

standard runtime libraries is inserted right into the executable. For code

in DLL‘s, only references are inserted.

The C# compiler doesn‘t require library files. Because the compiler is

already accessing the actual DLL, it can insert references to that DLL

into the executable. At the time the program is run, the CLR links the

program with the actual method call in mscorlib.dll.

Many of the basic classes and structures are included in mscorlib.dll. As

you go beyond the command line, you‘ll start encountering classes that

are stored in other DLLs. For example, classes in the System.Windows.-

Forms namespace are stored in the assembly system.windows.forms,

which is the DLL system.windows.forms.dll.

The C# compiler will access mscorlib.dll by default, but for other DLLs,

you‘ll need to tell the compiler the assembly in which the classes are

located. These are known as references. In Visual Studio, right click

References under the project name in the Solution Explorer, and select

Add Reference. Or, select Add Reference from the Project menu. (For the

command line compiler, you specify references with the /r compiler

switch.)

It may seem like a big bother to type System.Console.WriteLine just to

display a line of text, and that‘s why the C# language supports a directive

that reduces your typing a bit. This program is functionally equivalent to

the program shown earlier:

.NET Book Zero Charles Petzold

Version 1.1 Page 19

SecondProgram.cs

//----------------------------------------------

using System;

class SecondProgram

{

public static void Main()

{

Console.WriteLine("Hello, Microsoft .NET Framework!");

}

The Console.WriteLine call is no longer prceded with the System name-

space. This is made possible by the line near the top that begins with the

keyword using. This line is called a directive because it‘s not, strictly

speaking, a statement. It must appear before any type definition in the

file, such as a class. The using directive basically tells the C# compiler

that if it can‘t find a static method named Console.WriteLine, it should try

appending System to the front to make System.Console.WriteLine and try

looking for that.

Of course, the using directive hasn‘t exactly reduced the size of the pro-

gram, but if you had very many WriteLine calls, it certainly would. All the

sample programs from now on will have a using directive for the System

namespace and occasionally other namespaces as well.

The using directive is not like a header file, and it‘s not like a library file.

It doesn‘t reference a file. The using directive only indicates a namespace,

and having using directives is never required in a C# program.

A slightly different form of the using directive defines an alias that lets

you decrease your repetitive typing even more.

ThirdProgram.cs

//---------------------------------------------

using C = System.Console;

class ThirdProgram

{

public static void Main()

{

C.WriteLine("Hello, Microsoft .NET Framework!");

}

Now any reference to the System.Console class can be shortened to just a

capital C. That‘s about as succinct as you‘re going to get here. (The next

step would involve defining your own short-named method that then

calls WriteLine.)

剩余266页未读，继续阅读

阿秋秋

粉丝: 4
资源: 2

.NET入门精要：Charles Petzold的.NET Book Zero解析

.NET零本书：C或C ++程序员需要了解的C＃和.NET Framework.NET Book Zero: What the C or C++ Programmer Needs to Know about C# and the .NET Framework

Charles Petzold.zip

Head First C# 英文版 7-6

C++程序员转战C#与.NET框架必读：Petzold的《.NET Book Zero》详解

.NET初学者入门：C#与.NET框架解析

.NET入门指南：Charles Petzold著

.NET编程基础：从零开始

.NET初学者指南：C/C++程序员须知

C#入门指南：.NET初学者必读——与C++对比

教师节主题班会.pptx

最新资源