C#语言规范详解：类型、变量、表达式、语句等

需积分: 9 167 浏览量更新于2025-01-05 收藏 5.87MB PDF 举报

C# 初学者的学习资料本资源是 C# 初学者的很好的学习资料，为 PDF 格式的文件，详细地描述了 C# 的各种语法。本文将从标题、描述、标签和部分内容等方面对该资源进行详细的解析，并生成相关的知识点。 **标题：C# 初学者的学习资料** 该标题表明该资源是专门为 C# 初学者设计的学习资料，旨在帮助初学者快速掌握 C# 的基础知识和语法。 **描述：C# 初学者的很好的资料** 该描述进一步强调了该资源的价值，表明该资源是 C# 初学者的很好的学习资料，可以满足初学者的需求。 **标签：C#** 该标签表明该资源的主要主题是 C#，因此相关的知识点将主要围绕 C# 编程语言展开。 **部分内容：C# Language Specification** 该部分内容是 C# 语言规范的详细描述，涵盖了 C# 的各种语法和特性，如类型和变量、表达式、语句、类和对象、方法等。 **知识点：** 1. **C# 语言基础**：C# 语言的基础知识，包括 HelloWorld 程序、程序结构、类型和变量、表达式、语句等。 2. **类型和变量**：C# 中的类型和变量，包括基本类型、复杂类型、数组、枚举类型等。 3. **表达式**：C# 中的表达式，包括算术表达式、关系表达式、逻辑表达式、赋值表达式等。 4. **语句**：C# 中的语句，包括 if 语句、switch 语句、循环语句、跳转语句等。 5. **类和对象**：C# 中的类和对象，包括成员、访问修饰符、类型参数、基类、字段、方法等。 6. **方法**：C# 中的方法，包括方法的定义、方法的调用、参数、返回类型、方法的重载等。 7. **继承和多态**：C# 中的继承和多态，包括基类、派生类、虚拟方法、抽象方法、重写方法等。本资源是 C# 初学者的非常有价值的学习资料，涵盖了 C# 的基础知识和语法，对初学者具有重要的参考价值。

Chapter 错误！未定义样式。错误！未定义样式。

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

C# LANGUAGE SPECIFICATION

csc hello.cs

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 错误！未定义样式。错误！未定义样式。

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

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.

Category Description

Signed integral: sbyte, short, int, long

Unsigned integral: byte, ushort, uint, ulong

Unicode characters: char

IEEE floating point: float, double

High-precision decimal: decimal

Simple types

Boolean:

bool

Enum types User-defined types of the form enum E {...}

Struct types User-defined types of the form struct S {...}

Value

types

Nullable types Extensions of all other value types with a

null value

Ultimate base class of all other types: object

Unicode strings: string

Class types

User-defined types of the form

class C {...}

Interface types User-defined types of the form interface I {...}

Array types Single- and multi-dimensional, for example, int[] and

int[,]

Reference

types

Delegate types User-defined types of the form e.g. delegate int D(...)

The eight integral types provide support for 8-bit, 16-bit, 32-bit, and 64-bit values in signed or unsigned form.

The two floating point types,

float and double, are represented using the 32-bit single-precision and 64-bit

double-precision IEEE 754 formats.

The decimal type is a 128-bit data type suitable for financial and monetary calculations.

C#’s

bool type is used to represent boolean values—values that are either true or false.

Character and string processing in C# uses Unicode encoding. The char type represents a UTF-16 code unit,

and the

string type represents a sequence of UTF-16 code units.

The following table summarizes C#’s numeric types.

剩余518页未读，继续阅读

eva_me

粉丝: 8
资源: 5

C#语言规范详解：类型、变量、表达式、语句等

C#初学者学习C#初学者学习C#初学者学习C#初学者学习C#初学者学习

C#初学者编程实例

C#初学者简单计算器

c#初学者资料

一款很适合C#初学者学习的计算器

C#经典完全手册.pdf---c#初学者学习必备

.NET使用Visual Studio开发，C#初学者学习教程

C#完全手册 (C#初学者资料)

c#初学者最红的学习参考

C#初学者课件C#初学者课件

最新资源