.NET编程规范5.0：C#语言核心指南

需积分: 9 97 浏览量更新于2024-07-17 收藏 3.63MB PDF 举报

“微软.Net编程规范5.0--原版.pdf” C#是一种简单、现代、面向对象且类型安全的编程语言，它的语法根植于C系列语言，对C、C++和Java程序员来说非常熟悉。C#已被ECMA国际标准化为ECMA-334标准，并由ISO/IEC标准化为ISO/IEC 23270标准，微软的.NET Framework上的C#编译器是这两个标准的符合实现。 C#不仅仅是一种面向对象的语言，它还包含了对组件导向编程的支持。现代软件设计越来越依赖于自包含、自我描述的功能性软件组件。这些组件通过属性、方法和事件提供编程模型，具有提供声明性信息的特性，并包含自己的文档。C#语言为此提供了直接支持的构造，使得在C#中创建和使用组件变得非常自然。在C# 5.0版本中，语言规范强调了以下几个关键知识点： 1. **类型系统**：C#拥有强大的类型系统，确保代码的安全性和效率。类型安全意味着在编译时就能检测到潜在的类型错误，避免了运行时的异常。 2. **面向对象编程**：C#支持类、接口、继承、多态等面向对象特性，允许程序员通过封装、继承和多态来组织和重用代码。 3. **组件编程**：通过属性、方法和事件，C#支持组件模型，允许组件之间以声明性方式交互，增强了代码的可复用性。 4. **属性（Properties）**：属性是C#中访问类成员的一种机制，它提供了数据访问的控制，可以包含访问检查或其他逻辑。 5. **事件（Events）**：事件是对象间通信的一种方式，主要用于处理异步操作或通知其他对象特定事件的发生。 6. **方法（Methods）**：方法是包含在类中的行为，可以被其他代码调用来执行特定任务。 7. **特性（Attributes）**：特性提供了一种向元数据添加信息的方式，这些信息可以在编译时或运行时被反射机制读取，用于实现代码的自描述。 8. **文档注释（XML Documentation Comments）**：C#支持使用三重引号（///）进行文档注释，这些注释可以被工具（如XML文档生成器）用来生成API文档。 9. **泛型（Generics）**：泛型允许在不指定具体类型的情况下编写代码，提高了代码的灵活性和效率。 10. **匿名类型和LINQ（Language Integrated Query）**：C# 3.0引入了匿名类型和LINQ，简化了数据查询和处理。 11. **异步编程**：C# 5.0引入了`async`和`await`关键字，使得异步编程更为简洁，有助于提高程序的响应性和性能。 12. **自动属性（Auto-Implemented Properties）**：自动属性减少了代码的冗余，简化了类的定义。 13. **动态类型（Dynamic）**：动态类型允许在运行时确定类型，提供了与动态语言类似的灵活性。 14. **命名参数和可选参数**：这些特性允许函数调用时参数的灵活传递，提高了代码的可读性和可维护性。 15. **错误处理**：C#使用`try-catch-finally`语句块来捕获和处理异常，确保程序在遇到错误时能够优雅地处理。微软的.Net编程规范5.0详细阐述了C#语言的关键特性和最佳实践，是开发者理解和遵循C#编程规范的重要参考文档。通过遵循这些规范，开发人员可以编写出更高效、可维护和易于理解的代码。

public Color(byte r, byte g, byte b) {

this.r = r;

this.g = g;

this.b = b;

}

As shown in the previous example, read-only fields may be declared with a readonly modifier. Assignment to

a readonly field can only occur as part of the field’s declaration or in a constructor in the same class.

1.6.6 Methods

A method is a member that implements a computation or action that can be performed by an object or class.

Static methods are accessed through the class. Instance methods are accessed through instances of the class.

Methods have a (possibly empty) list of parameters, which represent values or variable references passed to the

method, and a return type, which specifies the type of the value computed and returned by the method. A

method’s return type is void if it does not return a value.

Like types, methods may also have a set of type parameters, for which type arguments must be specified when

the method is called. Unlike types, the type arguments can often be inferred from the arguments of a method call

and need not be explicitly given.

The signature of a method must be unique in the class in which the method is declared. The signature of a

method consists of the name of the method, the number of type parameters and the number, modifiers, and types

of its parameters. The signature of a method does not include the return type.

1.6.6.1 Parameters

Parameters are used to pass values or variable references to methods. The parameters of a method get their

actual values from the arguments that are specified when the method is invoked. There are four kinds of

parameters: value parameters, reference parameters, output parameters, and parameter arrays.

A value parameter is used for input parameter passing. A value parameter corresponds to a local variable that

gets its initial value from the argument that was passed for the parameter. Modifications to a value parameter do

not affect the argument that was passed for the parameter.

Value parameters can be optional, by specifying a default value so that corresponding arguments can be omitted.

A reference parameter is used for both input and output parameter passing. The argument passed for a reference

parameter must be a variable, and during execution of the method, the reference parameter represents the same

storage location as the argument variable. A reference parameter is declared with the ref modifier. The

following example shows the use of ref parameters.

using System;

class Test

{

static void Swap(ref int x, ref int y) {

int temp = x;

x = y;

y = temp;

}

static void Main() {

int i = 1, j = 2;

Swap(ref i, ref j);

Console.WriteLine("{0} {1}", i, j); // Outputs "2 1"

}

Chapter 错误!使用“开始”选项卡将 Heading 1 应用于要在此处显示的文字。错误!使用“开始”选项卡将 Heading 1 应用于要在此处显示的文字。

An output parameter is used for output parameter passing. An output parameter is similar to a reference

parameter except that the initial value of the caller-provided argument is unimportant. An output parameter is

declared with the out modifier. The following example shows the use of out parameters.

using System;

class Test

{

static void Divide(int x, int y, out int result, out int remainder) {

result = x / y;

remainder = x % y;

}

static void Main() {

int res, rem;

Divide(10, 3, out res, out rem);

Console.WriteLine("{0} {1}", res, rem); // Outputs "3 1"

}

A parameter array permits a variable number of arguments to be passed to a method. A parameter array is

declared with the params modifier. Only the last parameter of a method can be a parameter array, and the type

of a parameter array must be a single-dimensional array type. The Write and WriteLine methods of the

System.Console class are good examples of parameter array usage. They are declared as follows.

public class Console

{

public static void Write(string fmt, params object[] args) {...}

public static void WriteLine(string fmt, params object[] args) {...}

...

}

Within a method that uses a parameter array, the parameter array behaves exactly like a regular parameter of an

array type. However, in an invocation of a method with a parameter array, it is possible to pass either a single

argument of the parameter array type or any number of arguments of the element type of the parameter array. In

the latter case, an array instance is automatically created and initialized with the given arguments. This example

Console.WriteLine("x={0} y={1} z={2}", x, y, z);

is equivalent to writing the following.

string s = "x={0} y={1} z={2}";

object[] args = new object[3];

args[0] = x;

args[1] = y;

args[2] = z;

Console.WriteLine(s, args);

1.6.6.2 Method body and local variables

A method’s body specifies the statements to execute when the method is invoked.

A method body can declare variables that are specific to the invocation of the method. Such variables are called

local variables. A local variable declaration specifies a type name, a variable name, and possibly an initial value.

The following example declares a local variable i with an initial value of zero and a local variable j with no

initial value.

using System;

class Squares

{

static void Main() {

int i = 0;

int j;

while (i < 10) {

j = i * i;

Console.WriteLine("{0} x {0} = {1}", i, j);

i = i + 1;

}

C# requires a local variable to be definitely assigned before its value can be obtained. For example, if the

declaration of the previous i did not include an initial value, the compiler would report an error for the

subsequent usages of i because i would not be definitely assigned at those points in the program.

A method can use return statements to return control to its caller. In a method returning void, return

statements cannot specify an expression. In a method returning non-void, return statements must include an

expression that computes the return value.

1.6.6.3 Static and instance methods

A method declared with a static modifier is a static method. A static method does not operate on a specific

instance and can only directly access static members.

A method declared without a static modifier is an instance method. An instance method operates on a

specific instance and can access both static and instance members. The instance on which an instance method

was invoked can be explicitly accessed as this. It is an error to refer to this in a static method.

The following Entity class has both static and instance members.

class Entity

{

static int nextSerialNo;

int serialNo;

public Entity() {

serialNo = nextSerialNo++;

}

public int GetSerialNo() {

return serialNo;

}

public static int GetNextSerialNo() {

return nextSerialNo;

}

public static void SetNextSerialNo(int value) {

nextSerialNo = value;

}

Each Entity instance contains a serial number (and presumably some other information that is not shown here).

The Entity constructor (which is like an instance method) initializes the new instance with the next available

serial number. Because the constructor is an instance member, it is permitted to access both the serialNo

instance field and the nextSerialNo static field.

The GetNextSerialNo and SetNextSerialNo static methods can access the nextSerialNo static field, but

it would be an error for them to directly access the serialNo instance field.

The following example shows the use of the Entity class.

Chapter 错误!使用“开始”选项卡将 Heading 1 应用于要在此处显示的文字。错误!使用“开始”选项卡将 Heading 1 应用于要在此处显示的文字。

using System;

class Test

{

static void Main() {

Entity.SetNextSerialNo(1000);

Entity e1 = new Entity();

Entity e2 = new Entity();

Console.WriteLine(e1.GetSerialNo()); // Outputs "1000"

Console.WriteLine(e2.GetSerialNo()); // Outputs "1001"

Console.WriteLine(Entity.GetNextSerialNo()); // Outputs "1002"

}

Note that the SetNextSerialNo and GetNextSerialNo static methods are invoked on the class whereas the

GetSerialNo instance method is invoked on instances of the class.

1.6.6.4 Virtual, override, and abstract methods

When an instance method declaration includes a virtual modifier, the method is said to be a virtual method.

When no virtual modifier is present, the method is said to be a non-virtual method.

When a virtual method is invoked, the run-time type of the instance for which that invocation takes place

determines the actual method implementation to invoke. In a nonvirtual method invocation, the compile-time

type of the instance is the determining factor.

A virtual method can be overridden in a derived class. When an instance method declaration includes an

override modifier, the method overrides an inherited virtual method with the same signature. Whereas a

virtual method declaration introduces a new method, an override method declaration specializes an existing

inherited virtual method by providing a new implementation of that method.

An abstract method is a virtual method with no implementation. An abstract method is declared with the

abstract modifier and is permitted only in a class that is also declared abstract. An abstract method must

be overridden in every non-abstract derived class.

The following example declares an abstract class, Expression, which represents an expression tree node, and

three derived classes, Constant, VariableReference, and Operation, which implement expression tree

nodes for constants, variable references, and arithmetic operations. (This is similar to, but not to be confused

with the expression tree types introduced in section §4.6).

using System;

using System.Collections;

public abstract class Expression

{

public abstract double Evaluate(Hashtable vars);

}

public class Constant: Expression

{

double value;

public Constant(double value) {

this.value = value;

}

public override double Evaluate(Hashtable vars) {

return value;

}

public class VariableReference: Expression

{

string name;

public VariableReference(string name) {

this.name = name;

}

public override double Evaluate(Hashtable vars) {

object value = vars[name];

if (value == null) {

throw new Exception("Unknown variable: " + name);

}

return Convert.ToDouble(value);

}

public class Operation: Expression

{

Expression left;

char op;

Expression right;

public Operation(Expression left, char op, Expression right) {

this.left = left;

this.op = op;

this.right = right;

}

public override double Evaluate(Hashtable vars) {

double x = left.Evaluate(vars);

double y = right.Evaluate(vars);

switch (op) {

case '+': return x + y;

case '-': return x - y;

case '*': return x * y;

case '/': return x / y;

}

throw new Exception("Unknown operator");

}

The previous four classes can be used to model arithmetic expressions. For example, using instances of these

classes, the expression x + 3 can be represented as follows.

Expression e = new Operation(

new VariableReference("x"),

'+',

new Constant(3));

The Evaluate method of an Expression instance is invoked to evaluate the given expression and produce a

double value. The method takes as an argument a Hashtable that contains variable names (as keys of the

entries) and values (as values of the entries). The Evaluate method is a virtual abstract method, meaning that

non-abstract derived classes must override it to provide an actual implementation.

A Constant’s implementation of Evaluate simply returns the stored constant. A VariableReference’s

implementation looks up the variable name in the hashtable and returns the resulting value. An Operation’s

implementation first evaluates the left and right operands (by recursively invoking their Evaluate methods)

and then performs the given arithmetic operation.

The following program uses the Expression classes to evaluate the expression x * (y + 2) for different values

of x and y.

using System;

using System.Collections;

class Test

{

static void Main() {

剩余512页未读，继续阅读

HilTan

粉丝: 0
资源: 13

.NET编程规范5.0：C#语言核心指南

Abhi_pdf-5.0-py3-none-any.whl.zip压缩包内容解析

spring-tx-5.0.0.0.RELEASE.jar在Java开发中的应用

TypeScript 5.0-rc版与Node.js的集成与应用

IEC 61000-3-2-2018 Ed.5.0-2018-GZ.pdf

dotnet-intellisense-5.0-zh-hans.zip

dotnet-sdk-5.0.100-preview.7.20366.6-win-x64.exe

dotnet-sdk-5.0.100-preview.7.20319.6-win-x64.exe

secoclient-macosx-5.0.3.20.tar.gz

Deveco Studio（devecostudio-mac-arm-5.0.3.900.zip.002)

Deveco Studio（devecostudio-mac-arm-5.0.3.900.zip.001)

最新资源