C#语言规范详解：入门与核心特性

需积分: 0 80 浏览量更新于2024-07-23 收藏 3.77MB PDF 举报

C#语言规范(C# Language Specification)是Microsoft Corporation于1999年至2012年期间发布的官方文档，旨在提供C#编程语言的详尽指导。这份文档对于深入理解C#的语法、结构以及核心概念至关重要，是C#开发者的必读参考资料。 1. **简介**：章节1介绍了C#语言的基本概念，包括"Hello World"示例，展示了如何编写一个简单的程序来显示欢迎信息。这是学习任何编程语言的第一步，通过这个例子，开发者可以熟悉C#的基本语法和输出语句。 2. **程序结构**：C#的程序结构清晰，包括类和对象的概念。类是数据和行为的封装单位，而对象则是类的具体实例。理解如何组织代码，如类的定义、构造函数和访问修饰符（如public、private等）是至关重要的。 3. **类型和变量**：C#支持多种数据类型，包括基本类型如整数、浮点数、字符，以及引用类型如类和接口。变量是用于存储数据的占位符，程序员需要了解如何声明、初始化和操作不同类型的变量。 4. **表达式**：表达式是C#中的计算单元，包括算术表达式、逻辑表达式、字符串连接等。理解如何构建和解析表达式有助于处理复杂的数据操作。 5. **语句**：C#的语句涵盖了控制流程，如条件语句（if-else）、循环（for、while）、异常处理等。这些是编程中不可或缺的部分，用于控制程序的执行流程。 6. **类和对象**：深入剖析了类的成员，如成员变量（字段）和方法（包括参数、局部变量、静态和实例方法、虚方法、重写和抽象方法）。这些概念构成了面向对象编程的核心。 7. **访问修饰符**：这部分介绍了如何控制类、方法和成员的可见性和封装性，这对于代码的封装和模块化设计至关重要。 8. **继承与多态**：C#支持基于类的继承，通过基类和派生类实现代码复用。此外，通过虚拟、重写和抽象方法，开发者可以创建灵活的多态性，使得子类可以根据需要扩展父类的行为。 C#语言规范文档是C#程序员的宝典，它详细阐述了C#编程语言的基础语法、关键概念和高级特性。无论是初学者还是经验丰富的开发人员，都需要定期查阅此文档以保持对语言最新特性的理解和熟练运用。

C# LANGUAGE SPECIFICATION

xvi Copyright



B.2.4 Expressions ........................................................................................................................................ 485

B.2.5 Statements .......................................................................................................................................... 492

B.2.6 Namespaces ........................................................................................................................................ 495

B.2.7 Classes ................................................................................................................................................ 496

B.2.8 Structs ................................................................................................................................................. 503

B.2.9 Arrays ................................................................................................................................................. 504

B.2.10 Interfaces .......................................................................................................................................... 504

B.2.11 Enums ............................................................................................................................................... 505

B.2.12 Delegates .......................................................................................................................................... 506

B.2.13 Attributes .......................................................................................................................................... 506

B.3 Grammar extensions for unsafe code ........................................................................................................ 508

C. References ..................................................................................................................................................... 511

Chapter 1 Introduction



1. Introduction

C# (pronounced “See Sharp”) is a simple, modern, object-oriented, and type-safe programming language. C#

has its roots in the C family of languages and will be immediately familiar to C, C++, and Java programmers.

C# is standardized by ECMA International as the ECMA-334 standard and by ISO/IEC as the ISO/IEC 23270

standard. Microsoft’s C# compiler for the .NET Framework is a conforming implementation of both of these

standards.

C# is an object-oriented language, but C# further includes support for component-oriented programming.

Contemporary software design increasingly relies on software components in the form of self-contained and

self-describing packages of functionality. Key to such components is that they present a programming model

with properties, methods, and events; they have attributes that provide declarative information about the

component; and they incorporate their own documentation. C# provides language constructs to directly support

these concepts, making C# a very natural language in which to create and use software components.

Several C# features aid in the construction of robust and durable applications: Garbage collection automatically

reclaims memory occupied by unused objects; exception handling provides a structured and extensible

approach to error detection and recovery; and the type-safe design of the language makes it impossible to read

from uninitialized variables, to index arrays beyond their bounds, or to perform unchecked type casts.

C# has a unified type system. All C# types, including primitive types such as int and double, inherit from a

single root object type. Thus, all types share a set of common operations, and values of any type can be stored,

transported, and operated upon in a consistent manner. Furthermore, C# supports both user-defined reference

types and value types, allowing dynamic allocation of objects as well as in-line storage of lightweight structures.

To ensure that C# programs and libraries can evolve over time in a compatible manner, much emphasis has been

placed on versioning in C#’s design. Many programming languages pay little attention to this issue, and, as a

result, programs written in those languages break more often than necessary when newer versions of dependent

libraries are introduced. Aspects of C#’s design that were directly influenced by versioning considerations

include the separate virtual and override modifiers, the rules for method overload resolution, and support

for explicit interface member declarations.

The rest of this chapter describes the essential features of the C# language. Although later chapters describe

rules and exceptions in a detail-oriented and sometimes mathematical manner, this chapter strives for clarity and

brevity at the expense of completeness. The intent is to provide the reader with an introduction to the language

that will facilitate the writing of early programs and the reading of later chapters.

1.1 Hello world

The “Hello, World” program is traditionally used to introduce a programming language. Here it is in C#:

using System;

class Hello

{

static void Main() {

Console.WriteLine("Hello, World");

}

C# source files typically have the file extension .cs. Assuming that the “Hello, World” program is stored in the

file hello.cs, the program can be compiled with the Microsoft C# compiler using the command line

csc hello.cs

C# LANGUAGE SPECIFICATION

2 Copyright



which produces an executable assembly named hello.exe. The output produced by this application when it is

run is

Hello, World

The “Hello, World” program starts with a using directive that references the System namespace. Namespaces

provide a hierarchical means of organizing C# programs and libraries. Namespaces contain types and other

namespaces—for example, the System namespace contains a number of types, such as the Console class

referenced in the program, and a number of other namespaces, such as IO and Collections. A using

directive that references a given namespace enables unqualified use of the types that are members of that

namespace. Because of the using directive, the program can use Console.WriteLine as shorthand for

System.Console.WriteLine.

The Hello class declared by the “Hello, World” program has a single member, the method named Main. The

Main method is declared with the static modifier. While instance methods can reference a particular

enclosing object instance using the keyword this, static methods operate without reference to a particular

object. By convention, a static method named Main serves as the entry point of a program.

The output of the program is produced by the WriteLine method of the Console class in the System

namespace. This class is provided by the .NET Framework class libraries, which, by default, are automatically

referenced by the Microsoft C# compiler. Note that C# itself does not have a separate runtime library. Instead,

the .NET Framework is the runtime library of C#.

1.2 Program structure

The key organizational concepts in C# are programs, namespaces, types, members, and assemblies. C#

programs consist of one or more source files. Programs declare types, which contain members and can be

organized into namespaces. Classes and interfaces are examples of types. Fields, methods, properties, and events

are examples of members. When C# programs are compiled, they are physically packaged into assemblies.

Assemblies typically have the file extension .exe or .dll, depending on whether they implement applications

or libraries.

The example

using System;

namespace Acme.Collections

{

public class Stack

{

Entry top;

public void Push(object data) {

top = new Entry(top, data);

}

public object Pop() {

if (top == null) throw new InvalidOperationException();

object result = top.data;

top = top.next;

return result;

}

class Entry

{

public Entry next;

public object data;

Chapter 1 Introduction



public Entry(Entry next, object data) {

this.next = next;

this.data = data;

}

declares a class named Stack in a namespace called Acme.Collections. The fully qualified name of this

class is Acme.Collections.Stack. The class contains several members: a field named top, two methods

named Push and Pop, and a nested class named Entry. The Entry class further contains three members: a

field named next, a field named data, and a constructor. Assuming that the source code of the example is

stored in the file acme.cs, the command line

csc /t:library acme.cs

compiles the example as a library (code without a Main entry point) and produces an assembly named

acme.dll.

Assemblies contain executable code in the form of Intermediate Language (IL) instructions, and symbolic

information in the form of metadata. Before it is executed, the IL code in an assembly is automatically

converted to processor-specific code by the Just-In-Time (JIT) compiler of .NET Common Language Runtime.

Because an assembly is a self-describing unit of functionality containing both code and metadata, there is no

need for #include directives and header files in C#. The public types and members contained in a particular

assembly are made available in a C# program simply by referencing that assembly when compiling the program.

For example, this program uses the Acme.Collections.Stack class from the acme.dll assembly:

using System;

using Acme.Collections;

class Test

{

static void Main() {

Stack s = new Stack();

s.Push(1);

s.Push(10);

s.Push(100);

Console.WriteLine(s.Pop());

}

If the program is stored in the file test.cs, when test.cs is compiled, the acme.dll assembly can be

referenced using the compiler’s /r option:

csc /r:acme.dll test.cs

This creates an executable assembly named test.exe, which, when run, produces the output:

100

C# permits the source text of a program to be stored in several source files. When a multi-file C# program is

compiled, all of the source files are processed together, and the source files can freely reference each other—

conceptually, it is as if all the source files were concatenated into one large file before being processed. Forward

declarations are never needed in C# because, with very few exceptions, declaration order is insignificant. C#

does not limit a source file to declaring only one public type nor does it require the name of the source file to

match a type declared in the source file.

C# LANGUAGE SPECIFICATION

4 Copyright



1.3 Types and variables

There are two kinds of types in C#: value types and reference types. Variables of value types directly contain

their data whereas variables of reference types store references to their data, the latter being known as objects.

With reference types, it is possible for two variables to reference the same object and thus possible for

operations on one variable to affect the object referenced by the other variable. With value types, the variables

each have their own copy of the data, and it is not possible for operations on one to affect the other (except in

the case of ref and out parameter variables).

C#’s value types are further divided into simple types, enum types, struct types, and nullable types, and C#’s

reference types are further divided into class types, interface types, array types, and delegate types.

The following table provides an overview of C#’s type system.

C#语言规范详解：入门与核心特性

C#编程规范4.0详解：类、对象与语言结构

C# 3.0 语言规范详解

C#语言规范3.0版详解

csharp language specification

Bash命令执行解析-CSharp语言规范5.0

Bash中文文档：作业控制变量详解

036GraphTheory(图论) matlab代码.rar

026SVM用于分类时的参数优化，粒子群优化算法，用于优化核函数的c,g两个参数(SVM PSO)Matlab代码.rar

药店管理-JAVA-基于springBoot的药店管理系统的设计与实现（毕业论文+开题）

【网络】基于matlab高动态网络拓扑中OSPF网络计算【含Matlab源码 10964期】.zip

最新资源