C# LANGUAGE SPECIFICATION

1• The program does not use either “::” or “->” operators. The “::” token is used only to separate a

2namespace alias from a member of the namespace, and the “->” operator is used in only a small fraction

3of programs (which involve unsafe code). The separator “.” is used in compound names such as

4Console.WriteLine.

5• The program does not contain forward declarations. Forward declarations are never needed, as

6declaration order is not significant.

7• The program does not use #include to import program text. Dependencies among programs are

8handled symbolically rather than textually. This approach eliminates barriers between applications

9written using multiple languages. For example, the Console class need not be written in C#.

108.2 Types

11C# supports two kinds of types: value types and reference types. Value types include simple types (e.g.,

12char, int, and float), enum types, and struct types. Reference types include class types, interface types,

13delegate types, and array types.

14Value types differ from reference types in that variables of the value types directly contain their data,

15whereas variables of the reference types store references to objects. With reference types, it is possible for

16two variables to reference the same object, and thus possible for operations on one variable to affect the

17object referenced by the other variable. With value types, the variables each have their own copy of the data,

18and it is not possible for operations on one to affect the other.

19The example

20using System;

21struct Struct1

22{

23public int Value;

24}

25class Class1

26{

27public int Value = 0;

28}

29class Test

30{

40}

41}

42shows this difference. The output produced is

43Values: 0, 123

44Refs: 123, 123

45The assignment to a field of the local variable val2 does not impact the local variable val1 because both

46local variables are of a value type (the type Struct1) and each local variable of a value type has its own

47storage. In contrast, the assignment ref2.Value = 123; affects the object that both ref1 and ref2

48reference.

49The lines

50Console.WriteLine("Values: {0}, {1}", val1.Value, val2.Value);

51Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);

16

Chapter 8 Language overview

1deserve further comment, as they demonstrate some of the string formatting behavior of

2Console.WriteLine, which, in fact, takes a variable number of arguments. The first argument is a string,

3which can contain numbered placeholders like {0} and {1}. Each placeholder refers to a trailing argument

4with {0} referring to the second argument, {1} referring to the third argument, and so on. Before the output

5is sent to the console, each placeholder is replaced with the formatted value of its corresponding argument.

6Developers can define new value types through enum and struct declarations, and can define new reference

7types via class, interface, and delegate declarations. The example

8using System;

9public enum Color

10{

11Red, Blue, Green

12}

13public struct Point

14{

15public int x, y;

16}

17public interface IBase

18{

19void F();

20}

21public interface IDerived: IBase

22{

23void G();

24}

25public class A

26{

29}

30}

31public class B: A, IDerived

32{

41}

42}

43public delegate void EmptyDelegate();

44shows an example of each kind of type declaration. Later clauses describe type declarations in detail.

458.2.1 Predefined types

46C# provides a set of predefined types, most of which will be familiar to C and C++ developers.

47The predefined reference types are object and string. The type object is the ultimate base type of all

48other types. The type string is used to represent Unicode string values. Values of type string are

49immutable.

50The predefined value types include signed and unsigned integral types, floating-point types, and the types

51bool, char, and decimal. The signed integral types are sbyte, short, int, and long; the unsigned

52integral types are byte, ushort, uint, and ulong; and the floating-point types are float and double.

17

Chapter 8 Language overview

1operations as the predefined integral types, and can define conversions between Digit and predefined

2types.

3The predefined types employ operator overloading themselves. For example, the comparison operators ==

4and != have different semantics for different predefined types:

5• Two expressions of type int are considered equal if they represent the same integer value.

6• Two expressions of type object are considered equal if both refer to the same object, or if both are

7null.

8• Two expressions of type string are considered equal if the string instances have identical lengths and

9identical characters in each character position, or if both are null.

10The example

11using System;

12class Test

13{

19}

20}

21produces the output

22True

23False

24because the first comparison compares two expressions of type string, and the second comparison

25compares two expressions of type object. (Note that when the Standard Library produces a string

26representation of a Boolean value, as is the case with System.WriteLine above, it uses “True” and

27“False”, while the corresponding C# language Boolean literals are spelled true and false.)

288.2.2 Conversions

29The predefined types also have predefined conversions. For instance, conversions exist between the

30predefined types int and long. C# differentiates between two kinds of conversions: implicit conversions

31and explicit conversions. Implicit conversions are supplied for conversions that can safely be performed

32without careful scrutiny. For instance, the conversion from int to long is an implicit conversion. This

33conversion always succeeds, and never results in a loss of information. The following example

34using System;

35class Test

36{

41}

42}

43implicitly converts an int to a long.

44In contrast, explicit conversions are performed with a cast expression. The example

45using System;

19