C#LanguageSpecification.pdf
(
2488 KB
)
Pobierz
C# Language Specification
Ecma TC39-TG2/2004/14
C
#
Language Specification
Working Draft 2.7, Jun, 2004
Public Review Document
Table of Contents
1
2
Table of Contents
3
4
Foreword...................................................................................................................................................... xvii
5
Introduction .................................................................................................................................................. xix
6
1. Scope............................................................................................................................................................. 1
7
2. Conformance ............................................................................................................................................... 3
8
3. Normative references .................................................................................................................................. 5
9
4. Definitions .................................................................................................................................................... 7
10
5. Notational conventions................................................................................................................................ 9
11
6. Acronyms and abbreviations ................................................................................................................... 11
12
7. General description ................................................................................................................................... 13
13
8. Language overview.................................................................................................................................... 15
14
8.1 Getting started ....................................................................................................................................... 15
8.2 Types ..................................................................................................................................................... 16
15
8.2.1 Predefined types ............................................................................................................................. 17
16
8.2.2 Conversions.................................................................................................................................... 19
17
8.2.3 Array types ..................................................................................................................................... 20
18
8.2.4 Type system unification ................................................................................................................. 22
19
8.3 Variables and parameters ...................................................................................................................... 22
20
8.4 Automatic memory management .......................................................................................................... 25
21
8.5 Expressions ........................................................................................................................................... 27
22
8.6 Statements ............................................................................................................................................. 28
23
8.7 Classes................................................................................................................................................... 31
24
8.7.1 Constants ........................................................................................................................................ 33
25
8.7.2 Fields.............................................................................................................................................. 33
26
8.7.3 Methods.......................................................................................................................................... 34
27
8.7.4 Properties ....................................................................................................................................... 35
28
8.7.5 Events............................................................................................................................................. 36
29
8.7.6 Operators ........................................................................................................................................ 37
30
8.7.7 Indexers .......................................................................................................................................... 38
31
8.7.8 Instance constructors...................................................................................................................... 39
32
8.7.9 Destructors ..................................................................................................................................... 40
33
8.7.10 Static constructors ........................................................................................................................ 40
34
8.7.11 Inheritance.................................................................................................................................... 41
35
8.7.12 Static classes ................................................................................................................................ 42
36
8.7.13 Partial type declarations ............................................................................................................... 42
37
8.8 Structs.................................................................................................................................................... 43
38
8.9 Interfaces ............................................................................................................................................... 44
39
8.10 Delegates ............................................................................................................................................. 45
40
8.11 Enums.................................................................................................................................................. 46
41
8.12 Namespaces and assemblies ................................................................................................................ 46
42
8.13 Versioning ........................................................................................................................................... 48
43
8.14 Extern Aliases ..................................................................................................................................... 49
44
8.15 Attributes............................................................................................................................................. 51
45
8.16 Generics............................................................................................................................................... 52
46
iii
C# LANGUAGE SPECIFICATION
1
8.16.1 Why generics?.............................................................................................................................. 52
8.16.2 Creating and consuming generics ................................................................................................ 53
2
8.16.3 Multiple type parameters.............................................................................................................. 54
3
8.16.4 Constraints ................................................................................................................................... 54
4
8.16.5 Generic methods .......................................................................................................................... 56
5
8.17 Anonymous methods........................................................................................................................... 56
6
8.18 Iterators ............................................................................................................................................... 59
7
8
9. Lexical structure........................................................................................................................................ 63
9
9.1 Programs ............................................................................................................................................... 63
9.2 Grammars .............................................................................................................................................. 63
10
9.2.1 Lexical grammar ............................................................................................................................ 63
11
9.2.2 Syntactic grammar ......................................................................................................................... 63
12
9.2.3 Grammar ambiguities..................................................................................................................... 64
13
9.3 Lexical analysis ..................................................................................................................................... 64
14
9.3.1 Line terminators ............................................................................................................................. 65
15
9.3.2 Comments ...................................................................................................................................... 65
16
9.3.3 White space .................................................................................................................................... 66
17
9.4 Tokens ................................................................................................................................................... 67
18
9.4.1 Unicode escape sequences ............................................................................................................. 67
19
9.4.2 Identifiers ....................................................................................................................................... 68
20
9.4.3 Keywords ....................................................................................................................................... 69
21
9.4.4 Literals ........................................................................................................................................... 70
22
9.4.4.1 Boolean literals........................................................................................................................ 70
23
9.4.4.2 Integer literals.......................................................................................................................... 70
24
9.4.4.3 Real literals.............................................................................................................................. 71
25
9.4.4.4 Character literals ..................................................................................................................... 72
26
9.4.4.5 String literals ........................................................................................................................... 73
27
9.4.4.6 The null literal ......................................................................................................................... 74
28
9.4.5 Operators and punctuators.............................................................................................................. 75
29
9.5 Pre-processing directives....................................................................................................................... 75
30
9.5.1 Conditional compilation symbols .................................................................................................. 76
31
9.5.2 Pre-processing expressions ............................................................................................................ 76
32
9.5.3 Declaration directives..................................................................................................................... 77
33
9.5.4 Conditional compilation directives ................................................................................................ 78
34
9.5.5 Diagnostic directives ...................................................................................................................... 80
35
9.5.6 Region control................................................................................................................................ 81
36
9.5.7 Line directives................................................................................................................................ 81
37
9.5.8 Pragma directives ........................................................................................................................... 82
38
39
10. Basic concepts .......................................................................................................................................... 83
40
10.1 Application startup .............................................................................................................................. 83
10.2 Application termination....................................................................................................................... 84
41
10.3 Declarations......................................................................................................................................... 84
42
10.4 Members.............................................................................................................................................. 87
43
10.4.1 Namespace members.................................................................................................................... 87
44
10.4.2 Struct members ............................................................................................................................ 87
45
10.4.3 Enumeration members ................................................................................................................. 87
46
10.4.4 Class members ............................................................................................................................. 87
47
10.4.5 Interface members........................................................................................................................ 88
48
10.4.6 Array members............................................................................................................................. 88
49
10.4.7 Delegate members ........................................................................................................................ 88
50
10.5 Member access .................................................................................................................................... 88
51
10.5.1 Declared accessibility................................................................................................................... 88
52
10.5.2 Accessibility domains .................................................................................................................. 89
53
iv
Table of Contents
1
10.5.3 Protected access for instance members ........................................................................................ 91
10.5.4 Accessibility constraints............................................................................................................... 92
2
10.6 Signatures and overloading ................................................................................................................. 93
3
10.7 Scopes ................................................................................................................................................. 94
4
10.7.1 Name hiding ................................................................................................................................. 96
5
10.7.1.1 Hiding through nesting.......................................................................................................... 96
6
10.7.1.2 Hiding through inheritance.................................................................................................... 97
7
10.8 Namespace and type names................................................................................................................. 98
8
10.8.1 Unqualified name ....................................................................................................................... 100
9
10.8.2 Fully qualified names ................................................................................................................. 100
10
10.9 Automatic memory management ...................................................................................................... 101
11
10.10 Execution order ............................................................................................................................... 103
12
13
11. Types ...................................................................................................................................................... 105
14
11.1 Value types........................................................................................................................................ 105
11.1.1 The System.ValueType type ...................................................................................................... 106
15
11.1.2 Default constructors ................................................................................................................... 106
16
11.1.3 Struct types................................................................................................................................. 107
17
11.1.4 Simple types ............................................................................................................................... 107
18
11.1.5 Integral types.............................................................................................................................. 108
19
11.1.6 Floating point types.................................................................................................................... 109
20
11.1.7 The decimal type ........................................................................................................................ 109
21
11.1.8 The bool type ............................................................................................................................. 110
22
11.1.9 Enumeration types...................................................................................................................... 110
23
11.2 Reference types ................................................................................................................................. 110
24
11.2.1 Class types.................................................................................................................................. 111
25
11.2.2 The object type........................................................................................................................... 111
26
11.2.3 The string type ........................................................................................................................... 111
27
11.2.4 Interface types ............................................................................................................................ 111
28
11.2.5 Array types ................................................................................................................................. 111
29
11.2.6 Delegate types ............................................................................................................................ 112
30
11.3 Boxing and unboxing ........................................................................................................................ 112
31
11.3.1 Boxing conversions.................................................................................................................... 112
32
11.3.2 Unboxing conversions................................................................................................................ 113
33
34
12. Variables ................................................................................................................................................ 115
35
12.1 Variable categories ............................................................................................................................ 115
12.1.1 Static variables ........................................................................................................................... 115
36
12.1.2 Instance variables ....................................................................................................................... 115
37
12.1.2.1 Instance variables in classes ................................................................................................ 115
38
12.1.2.2 Instance variables in structs................................................................................................. 116
39
12.1.3 Array elements ........................................................................................................................... 116
40
12.1.4 Value parameters........................................................................................................................ 116
41
12.1.5 Reference parameters ................................................................................................................. 116
42
12.1.6 Output parameters ...................................................................................................................... 116
43
12.1.7 Local variables ........................................................................................................................... 117
44
12.2 Default values.................................................................................................................................... 117
45
12.3 Definite assignment........................................................................................................................... 118
46
12.3.1 Initially assigned variables ......................................................................................................... 119
47
12.3.2 Initially unassigned variables ..................................................................................................... 119
48
12.3.3 Precise rules for determining definite assignment ..................................................................... 119
49
12.3.3.1 General rules for statements ................................................................................................ 120
50
12.3.3.2 Block statements, checked, and unchecked statements....................................................... 120
51
12.3.3.3 Expression statements ......................................................................................................... 120
52
12.3.3.4 Declaration statements ........................................................................................................ 120
53
v
Plik z chomika:
SacrA
Inne pliki z tego folderu:
Apress.Illustrated.C.Sharp.2005.Dec.2006.pdf
(17350 KB)
ApplicationDevelopmentUsingCSharpand.NET2001.chm
(5330 KB)
0470502207.pdf
(41717 KB)
Pearson-ASP.NET 4 Unleashed 2010.pdf
(37945 KB)
Accelerated_Silverlight_2009_namdatviet.pdf
(25714 KB)
Inne foldery tego chomika:
! .net c#(1)
#Visual Studio
c c++
C#
C#(1)
Zgłoś jeśli
naruszono regulamin