C# 6.0官方规范：入门与特性详解

需积分: 9 161 浏览量更新于2024-07-15 收藏 2.98MB PDF 举报

C# 6.0 Draft Specification 是一份详细的官方文档，涵盖了C# 6.0语言的草稿规范。C#是一种简单、现代且面向对象的编程语言，深受C、C++和Java程序员的欢迎。它的设计源于C家族，由ECMA国际标准化为ECMA-334标准，并被ISO/IEC作为ISO/IEC 23270标准认可。Microsoft为.NET Framework提供的C#编译器严格遵循这两个标准。 C# 6.0的关键特性包括： 1. **介绍**：该版本的C#引入了全新的功能，旨在提高开发者的生产力和代码的可读性。它强调了组件导向编程（Component-Oriented Programming），这是现代软件设计中的关键要素。 2. **词法结构**：C# 6.0的语法和符号规则进行了优化，以提供更清晰的代码表示。 3. **基本概念**：如类(class)和结构(struct)的处理，这些是面向对象编程的基础，展示了如何创建对象以及它们之间的关系。 4. **类型系统**：C# 6.0可能引入了新的类型支持，比如泛型和可空引用类型，以增强类型安全性和表达能力。 5. **变量和转换**：可能包含了对隐式类型转换和更智能的类型推断的支持，提高了编码效率。 6. **表达式和语句**：表达式的简化和新语法特性，如null-coalescing operator（条件空合并运算符）和lambda expressions（lambda表达式）。 7. **命名空间和程序集**：命名空间的管理得到了改进，有助于组织和管理大型项目中的代码。 8. **类和结构体**：可能对类的设计和接口的实现提供了新的灵活性和性能优化。 9. **数组和集合**：可能引入了数组的新特性或改进了集合框架，提升数据处理效率。 10. **接口**：接口的使用可能更加简洁，支持更好的多态性和接口实现的扩展。 11. **枚举**：C# 6.0可能提供了更方便枚举值的定义和操作。 12. **委托和事件**：委托和事件处理机制可能得到了增强，以便于创建和管理回调函数和事件驱动的应用。 13. **异常处理**：可能更新了异常处理机制，以提高异常处理的优雅度和效率。 14. **属性**：属性的访问修饰符和属性值的处理可能有所变化，以支持更多的元数据和自定义行为。 15. **不安全代码**：尽管C#是类型安全的语言，但文档中可能讨论了如何在特定条件下允许或控制使用不安全代码。 16. **文档注释**：C# 6.0可能强化了文档注释的标准和工具支持，以生成API文档和提高代码的可维护性。 17. **示例**：最后，文档中包含了一个简单的“Hello, World!”程序，展示了如何在C# 6.0中创建并运行一个基础应用程序。学习C# 6.0的开发者可以从中了解到新特性的细节，这将有助于他们在实际项目中更好地利用C#的强大功能。

public class Point

{

public int x, y;

public Point(int x, int y) {

this.x = x;

this.y = y;

}

Point p1 = new Point(0, 0);

Point p2 = new Point(10, 20);

MembersMembers

M E M B E RM E M B E R DESC RIP T IO NDESC RIP T IO N

Constants Constant values associated with the class

Fields Variables of the class

Methods Computations and actions that can be performed by the class

Properties Actions associated with reading and writing named properties

of the class

Indexers Actions associated with indexing instances of the class like an

array

Events Notifications that can be generated by the class

Operators Conversions and expression operators supported by the class

ClassesClasses

are the most fundamental of C#'s types. A class is a data structure that combines state (fields) and actions

(methods and other function members) in a single unit. A class provides a definition for dynamically created

instancesinstances

of the class, also known as

objectsobjects

. Classes support

inheritanceinheritance

and

polymorphismpolymorphism

, mechanisms

whereby

derived classesderived classes

can extend and specialize

base classesbase classes

New classes are created using class declarations. A class declaration starts with a header that specifies the

attributes and modifiers of the class, the name of the class, the base class (if given), and the interfaces implemented

by the class. The header is followed by the class body, which consists of a list of member declarations written

between the delimiters { and } .

The following is a declaration of a simple class named Point :

Instances of classes are created using the new operator, which allocates memory for a new instance, invokes a

constructor to initialize the instance, and returns a reference to the instance. The following statements create two

Point objects and store references to those objects in two variables:

The memory occupied by an object is automatically reclaimed when the object is no longer in use. It is neither

necessary nor possible to explicitly deallocate objects in C#.

The members of a class are either

static membersstatic members

instance membersinstance members

. Static members belong to classes, and

instance members belong to objects (instances of classes).

The following table provides an overview of the kinds of members a class can contain.

Constructors Actions required to initialize instances of the class or the class

itself

Destructors Actions to perform before instances of the class are

permanently discarded

Types Nested types declared by the class

M E M B E RM E M B E R DESC RIP T IO NDESC RIP T IO N

AccessibilityAccessibility

A C C ESSIB IL IT YA C C ESSIB IL IT Y M E A N IN GME A N IN G

public Access not limited

protected Access limited to this class or classes derived from this class

internal Access limited to this program

protected internal Access limited to this program or classes derived from this

class

private Access limited to this class

Type parametersType parameters

public class Pair<TFirst,TSecond>

{

public TFirst First;

public TSecond Second;

}

Pair<int,string> pair = new Pair<int,string> { First = 1, Second = "two" };

int i = pair.First; // TFirst is int

string s = pair.Second; // TSecond is string

Base classesBase classes

Each member of a class has an associated accessibility, which controls the regions of program text that are able to

access the member. There are five possible forms of accessibility. These are summarized in the following table.

A class definition may specify a set of type parameters by following the class name with angle brackets enclosing a

list of type parameter names. The type parameters can the be used in the body of the class declarations to define

the members of the class. In the following example, the type parameters of Pair are TFirst and TSecond :

A class type that is declared to take type parameters is called a generic class type. Struct, interface and delegate

types can also be generic.

When the generic class is used, type arguments must be provided for each of the type parameters:

A generic type with type arguments provided, like Pair<int,string> above, is called a constructed type.

A class declaration may specify a base class by following the class name and type parameters with a colon and the

name of the base class. Omitting a base class specification is the same as deriving from type object . In the

following example, the base class of Point3D is Point , and the base class of Point is object :

public class Point

{

public int x, y;

public Point(int x, int y) {

this.x = x;

this.y = y;

}

public class Point3D: Point

{

public int z;

public Point3D(int x, int y, int z): base(x, y) {

this.z = z;

}

Point a = new Point(10, 20);

Point b = new Point3D(10, 20, 30);

FieldsFields

public class Color

{

public static readonly Color Black = new Color(0, 0, 0);

public static readonly Color White = new Color(255, 255, 255);

public static readonly Color Red = new Color(255, 0, 0);

public static readonly Color Green = new Color(0, 255, 0);

public static readonly Color Blue = new Color(0, 0, 255);

private byte r, g, b;

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

this.r = r;

this.g = g;

this.b = b;

}

A class inherits the members of its base class. Inheritance means that a class implicitly contains all members of its

base class, except for the instance and static constructors, and the destructors of the base class. A derived class can

add new members to those it inherits, but it cannot remove the definition of an inherited member. In the previous

example, Point3D inherits the x and y fields from Point , and every Point3D instance contains three fields, x ,

y , and z .

An implicit conversion exists from a class type to any of its base class types. Therefore, a variable of a class type can

reference an instance of that class or an instance of any derived class. For example, given the previous class

declarations, a variable of type Point can reference either a Point or a Point3D :

A field is a variable that is associated with a class or with an instance of a class.

A field declared with the static modifier defines a

static fieldstatic field

. A static field identifies exactly one storage location.

No matter how many instances of a class are created, there is only ever one copy of a static field.

A field declared without the static modifier defines an

instance fieldinstance field

. Every instance of a class contains a

separate copy of all the instance fields of that class.

In the following example, each instance of the Color class has a separate copy of the r , g , and b instance fields,

but there is only one copy of the Black , White , Red , Green , and Blue static fields:

MethodsMethods

ParametersParameters

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"

}

As shown in the previous example,

read-only fieldsread-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.

methodmethod

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

Static methodsStatic methods

are accessed through the class.

Instance methodsInstance methods

are accessed through instances of the class.

Methods have a (possibly empty) list of

parametersparameters

, which represent values or variable references passed to the

method, and a

return typereturn 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

signaturesignature

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.

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

values from the

argumentsarguments

that are specified when the method is invoked. There are four kinds of parameters:

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

value parametervalue 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.

reference parameterreference 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.

output parameteroutput 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"

}

public class Console

{

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

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

...

}

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

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);

Method body and local variablesMethod body and local variables

parameter arrayparameter 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.

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

is equivalent to writing the following.

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 variableslocal 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.

剩余512页未读，继续阅读

Hope_2022

粉丝: 1
资源: 4

C# 6.0官方规范：入门与特性详解

C# 6.0 Draft Specification C#草稿规范6.0 中文版.pdf

CLR via C# 第4版 英文PDF

P802.11ax_D6.0_2019.zip.zip

IEEE Draft P802.11ac_D6.0 for ISO.pdf

NT35310 Draft SPEC V0.01.pdf

rtl8380_draft_datasheet.pdf

802.11ax draft6.0.pdf

OASIS_Standard_Draft[21591].pdf

CS5216_Datasheet_Draft_V0.2.pdf

社会安全挑战secure_societies_draft_wp clean.pdf

最新资源

CLR via C# 第4版英文PDF