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

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

《.NET Book Zero》是由Charles Petzold编著的一本经典著作，专为那些希望从C++转向C#编程的程序员设计。本书旨在帮助C++开发者深入了解C#语言以及.NET框架，以便更顺利地进行技术转型。作者以其深厚的技术背景和丰富的教学经验，通过详细的章节讲解，逐步揭示了C#的关键特性与.NET平台的核心概念。 1. **为什么这本书？(Chapter 1)**: 这一章探讨了为何在当前技术环境中，C++程序员有必要学习C#和.NET框架，强调了C#在现代软件开发中的重要性和.NET框架对于构建高效、可维护的分布式应用程序的价值。 2. **为什么选择.NET?(Chapter 2)**: 章节深入讨论了.NET框架的优势，如跨平台支持、类型安全、面向对象编程、自动内存管理以及其背后的Windows Presentation Foundation (WPF)、ASP.NET等组件的强大功能。 3. **运行时和SDKs概述(Chapter 3)**: 这部分介绍了.NET框架的运行环境（.NET Runtime）和开发工具套件(SDK)，包括安装和配置步骤，以及如何使用Visual Studio等集成开发环境进行C#项目开发。 4. **编辑、编译、运行和反汇编(Chapter 4)**: 详细讲解了C#程序的生命周期，包括代码编辑器的使用、编译过程、调试技巧以及如何通过反汇编理解底层执行机制。 5. **字符串和控制台输入输出(Chapter 5)**: 介绍了C#中处理文本数据的基础，包括字符串类型、字符串操作以及控制台应用程序的用户交互。 6. **基本数据类型和运算符(Chapter 6-8)**: 精准解析了C#的整型、浮点型、字符类型等基础数据类型，以及算术、逻辑和位操作符的用法。 7. **选择、循环和递归(Chapter 9-11)**: 理解控制结构的重要性，如条件语句、循环和递归，这些都是实现复杂算法和数据处理的基础。 8. **内存管理与数据结构(Chapter 9-12)**: 探讨栈和堆的概念，以及数组、集合和其他数据结构的使用，这对于理解和优化程序性能至关重要。 9. **面向对象编程(Chapter 13-21)**: 深入剖析类、结构体、对象、方法、构造函数、重载、继承、虚函数和接口等面向对象的核心概念。 10. **异常处理(Chapter 12)**: 讨论错误处理机制，包括try-catch-finally块，异常类和自定义异常处理。 11. **文件和流操作(Chapter 25)**: 学习如何读写文件，以及处理输入输出流，实现与磁盘、网络或其他外部资源的数据交换。《.NET Book Zero》是一本实用的指南，不仅适合初级C++转行者，也对有经验的开发者扩展C#技能和理解.NET框架提供了宝贵资源。通过阅读和实践书中的内容，读者将能快速熟悉C#语法，并掌握如何在.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页未读，继续阅读

sybifei

粉丝: 1
资源: 2

C++程序员转战C#与.NET框架必读：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

.NET书店

dot NET学习电子书

dotNet

dotnet:dotnet 实战笔记

dotnet项目

Ascgen dotNET

dotnet cleaner

dotNet Action

dotnet皮肤

最新资源