[c#]8.2.1 Predefined types(cont')

results in a compile-time error because the expression i = 0 is of type int,
and if statements require an
expression of type bool.
The char type is used to represent Unicode code units. A variable of type
char represents a single 16-bit
Unicode code unit.
The decimal type is appropriate for calculations in which rounding errors
caused by floating point
representations are unacceptable. Common examples include financial
calculations such as tax computations
and currency conversions. The decimal type provides 28 significant digits.
The table below lists the predefined types, and shows how to write literal
values for each of them.
Type Description Example
object The ultimate base type of all other types object o = null;
string String type; a string is a sequence of Unicode code
units
string s = "hello";
sbyte 8-bit signed integral type sbyte val = 12;
short 16-bit signed integral type short val = 12;
int 32-bit signed integral type int val = 12;
long 64-bit signed integral type long val1 = 12;
long val2 = 34L;
byte 8-bit unsigned integral type byte val1 = 12;
ushort 16-bit unsigned integral type ushort val1 = 12;
uint 32-bit unsigned integral type uint val1 = 12;
uint val2 = 34U;
ulong 64-bit unsigned integral type ulong val1 = 12;
ulong val2 = 34U;
ulong val3 = 56L;
ulong val4 = 78UL;
float Single-precision floating point type float val = 1.23F;
double Double-precision floating point type double val1 = 1.23;
double val2 = 4.56D;
bool Boolean type; a bool value is either true or false bool val1 = true;
bool val2 = false;
char Character type; a char value is a Unicode code unit char val = 抙?
decimal Precise decimal type with 28 significant digits decimal val = 1.23M;
Each of the predefined types is shorthand for a system-provided type. For
example, the keyword int refers
to the struct System.Int32. As a matter of style, use of the keyword is
favored over use of the complete
system type name.
Predefined value types such as int are treated specially in a few ways but
are for the most part treated
exactly like other structs. Operator overloading enables developers to
define new struct types that behave
much like the predefined value types. For instance, a Digit struct can
support the same mathematical
operations as the predefined integral types, and can define conversions
between Digit and predefined
types.
The predefined types employ operator overloading themselves. For example,
the comparison operators ==
and != have different semantics for different predefined types:
?Two expressions of type int are considered equal if they represent the
same integer value.
?Two expressions of type object are considered equal if both refer to
the ame object, or if both are null.
?Two expressions of type string are considered equal if the
string instances have identical lengths and
identical characters in each character position, or if both are
null.
The example:
using System;
                                    
class
Test                                                                        
{                                                                           
static void Main()
{                                                                           
string s = "Test";
string t = string.Copy(s);
Console.WriteLine(s == t);
Console.WriteLine((object)s == (object)t);
}                                                                           
}
                                                                           
produces the output
True                                                                        
False                                                                       
                                          
because the first comparison compares two expressions of type string,
and the second comparison 
                                                                
                               
compares two expressions of type object. (Note that when the
Standard Library produces a string
                                                                     
                       
representation of a Boolean value, as is the case with
System.WriteLine above, it uses .True. and
.False., while the corresponding C# language Boolean literals are
spelled true and false.)