C/C++程序员快速掌握C#与.NET框架指南

4星 · 超过85%的资源需积分: 9 28 浏览量更新于2024-07-25 收藏 1.24MB PDF 举报

"这篇文档是Charles Petzold所著的《What the C or C++ Programmer Needs to Know about C# and the .NET Framework》的Version 1.1版，旨在帮助有C++背景的开发者理解并快速掌握C#编程语言以及.NET框架。书中详细介绍了C#的基础知识和.NET平台的核心特性，内容涵盖了从为什么学习C#和.NET，到运行时环境、编译与调试、数据类型、控制结构、面向对象编程、异常处理、继承、接口、互操作性等多个方面。" 此书针对C++程序员，首先解释了为何要学习C#和.NET框架。C#作为微软推出的一种现代化的面向对象编程语言，它在语法和概念上与C++有很多相似之处，但同时也引入了许多新的特性和改进，如垃圾回收机制、统一的类型系统以及丰富的类库支持。.NET框架则提供了一个全面的开发环境，包括运行时环境（CLR）和软件开发工具包（SDK），使得开发者能够更高效地构建跨平台的应用程序。书中详细阐述了C#的基本编程元素，如字符串和控制台输入输出，基本数据类型（如整型、浮点型和布尔型），运算符和表达式，以及条件选择和循环控制结构。此外，还讨论了内存管理，包括栈和堆的概念，以及数组和集合的使用。在面向对象编程部分，作者介绍了方法、字段、对象实例化以及构造函数，探讨了等价性的概念，字段和属性的差异，以及继承和多态性。其中，虚拟性（Virtuality）章节讲解了C#中的抽象类、虚方法和重写，使C++程序员能够理解C#中如何实现动态绑定。接着，书中的章节涉及了操作符重载、接口的使用，以及与非托管代码（如C++/CLI）交互的互操作性。日期和时间的处理、事件和委托的使用，以及文件和流的管理，这些都是.NET开发中常见的实用主题。最后，书中还涵盖了文件和流的概念，这对于任何I/O密集型的程序设计都是至关重要的。通过学习这些内容，C++开发者可以快速过渡到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页未读，继续阅读

qz1012

粉丝: 1
资源: 6

C/C++程序员快速掌握C#与.NET框架指南

Foundations of Security What Every Programmer Needs to Know

A Programmer Guide to ADO.NET in C#

What every programmer should know about memory

What Every Programmer Should Know About Memory

Professional Refactoring in C# & ASP.NET (Wrox Programmer to Programmer)

01-what-every-programmer-should-know about-memory.pdf

WPF Programmer's Reference: Windows Presentation Foundation with C# 2010 and .NET 4

WPF Programmer’s Reference: Windows Presentation Foundation with C# 2010 and .NET 4

cpumemory-What Every Programmer Should Know About Memory.pdf

Exploring C++ The Programmer's Introduction to C++.

最新资源