ACCU Spring Conference,
Christ Church College,
Oxford,
Friday 30th March 2001. Jagger Software Limited
http://www.jaggersoft.com
Tel.  +44 (0) 1823 354 192
Hi, I'm Jon Jagger, a freelance software trainer, designer, and consultant. I specialise in curly bracket languages, hence { JSL }. In a former life I was QA Training's C++ and C product consultant. I'm an UK C++ standards panel member and a regular contributor to the ACCU Overload journal. I'm married with three increasingly larger children. My interests include training excellence, design, problem solving, and monty python (which should be required knowledge for all software developers). Forget the technical interview, just recite the parrot sketch. I don't really know what else to  say in a short bio such as this. I'm very very good at sleeping. And breathing. Both of which I practice a lot.

ACCU Spring Conference,
Christ Church College,
Oxford,
Friday 30th March 2001. Jagger Software Limited
http://www.jaggersoft.com
Tel.  +44 (0) 1823 354 192
Hi, I'm Jon Jagger, a freelance software trainer, designer, and consultant. I specialise in curly bracket languages, hence { JSL }. In a former life I was QA Training's C++ and C product consultant. I'm an UK C++ standards panel member and a regular contributor to the ACCU Overload journal. I'm married with three increasingly larger children. My interests include training excellence, design, problem solving, and monty python (which should be required knowledge for all software developers). Forget the technical interview, just recite the parrot sketch. I don't really know what else to  say in a short bio such as this. I'm very very good at sleeping. And breathing. Both of which I practice a lot.

ACCU Spring Conference,
Christ Church College,
Oxford,
Friday 30th March 2001. Jagger Software Limited
http://www.jaggersoft.com
Tel.  +44 (0) 1823 354 192
Hi, I'm Jon Jagger, a freelance software trainer, designer, and consultant. I specialise in curly bracket languages, hence { JSL }. In a former life I was QA Training's C++ and C product consultant. I'm an UK C++ standards panel member and a regular contributor to the ACCU Overload journal. I'm married with three increasingly larger children. My interests include training excellence, design, problem solving, and monty python (which should be required knowledge for all software developers). Forget the technical interview, just recite the parrot sketch. I don't really know what else to  say in a short bio such as this. I'm very very good at sleeping. And breathing. Both of which I practice a lot.

Static typing, runtime polymorphism (virtual methods), exceptions and "reference" types, are features also found in C#, C++ and Java. Value types, and operator overloading are features found in C#, C++ but not in Java. Compile time polymorphism (templates, aka generics) is promised for a later release of C#. A virtual execution system (similar to the Java VM), Object as the super base class of all types, single public inheritance (extension in Java), multiple public realization (implements in Java), non determinstic finalization, garbage collection, multithreading, and reflection are features found in C# and Java but not in C++. C# has a truly unified type system (achieved through boxing and unboxing, covered later). C++ does not. Java almost has a unified type system (primitive value types need to be manually wrapped).

Unlike in Java the name of the C# source file does not have to correspond to the name of the public class contained in that source file. There are several Main variations borrowed from C++ and Java. You can declare Main to return an int, with a return value of zero indicating success: The program's Main must be a static method. If there is more than one public static Main in a program one of them must be designated the entry point to the program using the /main:<type> command line option (where type is the name of the struct/class containing the selected Main).

Microsofts IL (Intermediate Language) is an important parts of the .NET VES (virtual execution system). The virtual execution model consists of an evaluation stack used for pushing arguments to methods and built-in operations.  At a method call the arguments (possibly including this) are transferred from the control of the calling method to the control of the called method.  Returned values of any instantiable type are pushed on the stack before method return. The IL instruction set can be divided into the following categories of instructions:

The important parts of the .NET VES (virtual execution system) are:

The purpose of this slide (written by a programmer with a soft Irish accent) is to present a code fragment that is dissected in the following slides.

The C# grammar distinguishes between a number of different tokens: identifiers, keywords, literals, operators and punctuators. Note that while C# does have a C/C++ like preprocessor, the #define directive is strictly limited to defining a simple token and cannot define a replacement set of tokens. This effectively means that preprocessing tokens do not exist. Which is nice. When generics (templates) are added to C# it is likely they will use the < > notation familiar to C++ programmers. It is also likely that C# will create a special exception to the maximal-much rule allowing >> to be parsed in context:

C# has a limited #define directive. You can use it to specify that the named pp-token is defined. You cannot #define true or false (this is because they can be used as bool literals inside a pp-expression). You can also use #undef to specify that the named pp-token is no longer defined. It is not an error if the specified pp-token is not already defined. There are no function macros, so both these are errors: #defined pp-tokens are only useful as part of the expression used to select or skip sections of code (skipped sections do not have to be syntactically well formed). The #line directive is useful for tools that generate C# code. There are no built-in __FILE__ or __LINE__ tokens in C#. The #error and #warning directives both emit a supplied pp-message diagnostic. A #error is fatal and halts the build, a #warning is non-fatal and does not halt the build. The #region and #endregion directives are used in pairs and can be nested. They have no declarative meaning. The editor in Visual Studio 7 uses them to create a folding editor.

The SDK guidelines recommend that public identifiers start with an uppercase letter using the PascalCase convertion and that private identifiers start with a lowercase letter using the camelCase convention. For example: In C# an identifier in a derived class can completely hide an identifier in a base class. Because of this you are strongly advised to follow this guideline. Note also that a CLS compliant program must not use public identifiers that differ only in case. For example:

The keywords in the above slide are coloured in blue. For those of you reading this in monochrome the keywords are using, public, class, static, void, int. Keywords have a fixed meaning. Part of learning a new language is learning the meaning of the keywords. Another more exciting part is learning how to create larger syntactic elements once the basic syntax has been grasped. But you have to start at the beginning. The time and effort expended learning the keywords and their meanings is well spent, especially as the keywords are fixed; they will not change (unlike just about everything else in computing!).

In Beta 1 there are 76 keywords that have a fixed meaning in all contexts. There are also a few 2nd-class keywords that have a fixed meaning only in certain special contexts. For example, value can be used as the name of a local variable almost everywhere. In one context (the set accessor of a property) value is effectively a keyword. This is not recommended and is presumably included for the benefit of code generation tools. You can also use the @ symbol to create verbatim-string literals that span many lines. This is useful when creating regular expressions for use with the Regex class. For example:

Only the built-in types have literal syntax. There is no way to create literals for user-defined structs or classes.

C# has a rich set of operators making it a very expressive langauge. All the operators in the table above are present in C#, C++, and Java. In C# all the above operators (except simple assignment) can be overloaded for user defined structs and classes. This is not possible in Java.

A C# class/struct/enum definition does not require a terminating semi-colon (like Java). However, as a concession to C++ programmers, a semi-colon may be used and has no affect on the meaning of the program: In Java a function declaration can have a trailing semi-colon. In C++ it cannot (but many compilers allow it). In C# it is not allowed and causes a compile time error:

It is illegal to declare a variable in a context where that variable would be unusable. For example: Declarations and expressions can be freely mixed. Most modern C++/Java style guidelines recommend delaying the declaration of a variable to increase the chance of being able to initialize it. This is important because C#, like Java, will not allow the value of a not-definitely assigned variable to be used. There are no pointers or typedefs in C#. Hence troublesome C++ declarations, such as:     int *ptr, value; // C/C++
are no longer an issue. A useful style is to declare multiple variables in the same declaration when the variables are necessarily of the same type:

A C# expression statement must have an affect on the program state. This means that only assignment, call, increment, decrement, and new expressions can be used as a statement (this is true for built in types and user-defined types): However, initialising a variable in a C# declaration statement is deemed a side effect: Hence the following are legal and at best generate a warning:

The first code box declares and intializes two bool variables called love and teeth. The second code box is identical to the first code box. System.Boolean is an alias for bool. They are synonyms. The third code box also uses the identifier Boolean as a synonym for bool. It does this using the shorthand notation of dropping the System. prefix which the compiler implicitly adds back in due to the using System; directive. The code in the third box generates an error. There is no global type called Boolean and there is no using System; directive so the compiler cannot resolve Boolean as the name of a type.

System.Boolean is a struct that lives inside the System namespace. It realizes a number of interfaces (structs and inheritance are fully covered later): Static methods of System.Boolean can be called using bool as an alias for System.Boolean:

Signed numbers and byte are in the Common Language Specification (CLS). ushort, uint, and ulong are not in CLS. The types that are part of the CLS form an integral [sic] part of the CTS (common type system) are are supported directly by the VES (virtual execution system). Note: a CLS compliant program cannot expose unsigned types in the public interface of a struct/interface/class but a CLS compliant program can use unsigned types in the private parts of a struct/class. The bitsizes of each type are precisely specified just like in Java (and unlike in C++). In code you can use the raw keyword type name (eg int) or its equivalent alias (eg System.Int32). There is no difference (except in runtime reflection when you have to use the string "System.Int32" rather than the string "int"). The guideline is to prefer the keyword. Note that a byte in C# is an unsigned 8 bit integer whereas in Java a byte is a signed 8 bit integer. The names of these 8 integral types in IL are intN (where N is the number of bits) for the signed types and unsigned intN, for the unsigned types. The byte and sbyte bit sizes are marked with an asterisk. This is because the minimum size of an array element is 16 bits (2 bytes).

System.Int32 is a struct that lives inside the System namespace. It realizes a number of interfaces (structs and inheritance are fully covered later): IFormattable is an interface that allows user-defined types to define their own format strings (in exactly the same whay that printf doesn't). The value of System.Int32.MinValue is unchecked ((int)0x80000000), that is, -2,147,483,648, == -(2^32) The value of System.Int32.MaxValue is 0x7FFFFFFF, that is, +2,147,483,647, == 2^32 – 1 int is a synonym for System.Int32. They can be used completely interchangeably.

The syntax for integer literals is the same in C# as it is in C++ and Java except for two minor differences: firstly, C# does not support octal integer literals; C++ and Java do. Secondly, C# supports unsigned integer literals (via the Uu suffix); Java does not. The keyword int is an alias for the System.Int32 struct. In C# int is classified as a simple-type and differs from other user-defined structs in a number of ways: • Most simple types have a syntax for creating literal values. For example 42 is a literal of type int, 23.11 is a literal of type double. C# offers no facility for creating literals of user-defined struct (or class) types. The values of user-defined structs (or classes) are usually created through constructors. • When the operands of an expression are all simple-type literals, the compiler can evaluate the expression as a compile-time expression. When the operands of an expression involve user-defined struct values, the expression will always be a runtime-expression. • You can declare immutable variables of simple types using the const keyword. You cannot declare immutable variables of user-defined structs (or classes) using the const keyword. As a matter of style, the C# language specification recommends using L instead of l when writing literals of type long since it is easy to confuse the letter l with the digit 1. In fact using lowercase l generates a warning. Why didn't they just enforce the use of uppercase suffixes?

C# defines the usual range of integer operators.

The pointer member access operator -> can only be used in unsafe (unmanaged) code. Strictly speaking an indexer is not considered an operator (there are some language rules this affects). Indexers can be defined for custom types. new is only ever used in conjunction with calling a constructor and is not overloadable. Using new to call a struct constructor allocates memory from the stack (honest) whereas using new to call a class constructor allocates memory from the heap. In C# structs are value types whereas classes are reference types. sizeof returns the size of a type or expression and can only be used in code marked as unsafe. checked and unchecked are used to control detection of integer arithmetic overflow (covered shortly).

All the unary operators can be overloaded for user-defined types. The type cast operator can be overloaded by creating implicit or explicit conversion operators. The multiplicative, additive, shift, relational (except for is and as), equality, and bitwise operators can also be overload for user-defined types. The && and || can sort of be overloaded by using true/false conversion operators (which retain the short-circuiting behaviour). Very strange. The conditional (?:) and the assignment operators cannot be overloaded. However, a compound assignment is effected in terms of its underlying operator which can be overloaded. This precedence table is essentially identical to that of C++ except that C++ has more operators. It is instructive to note the C++ operators that do not appear in the above table:

The associativity rules in C# are the same as in C++ and Java (which in turn were chosen for compatibility with C). Most expressions can be written naturally without parentheses. However, there are a few common idioms which require parentheses. For example:

By default compile time integer expressions generate an OverflowException and runtime integer expressions silently overflow. However this default behaviour is configurable. There is a command line option /checked+ to turn on overflow checking and similarly /checked- to turn off overflow checking. When overflow checking is on an expression that would normally silently wrap throws an OverflowException. You can also use the checked/unchecked operators to control overflow checking: checked expressions/statements are always checked, unchecked expressions/statements are never checked. A checked ( expression ) checks a single expression. It can be used on any expression but only affects the integer operators that can cause overflow: unary { ++, --, - }, binary { + - * / }, and explicit conversion operators between integral types. A checked expression is an expression; it has an outcome that can be used as part of a larger expression: A checked { statement } checks a sequence of statements. A checked statement does not have an outcome; it is not an expression.    int outcome = checked { ... }; // compile-time error The checked and unchecked operators only affect the overflow checking context of the operations they "textually" contain. They have no effect on textually contained function member invocations.

If the left hand operand is int or uint (32 bit types) the shift distance is always in the range 0 to 31 inclusive.  Only the five lowest-order bits of the right hand operand are used as the shift distance. If the left hand operand is long or ulong (64 bit types) the shift distance is always in the range 0 to 63 inclusive. Only the six lowest-order bits of the right hand operand are used as the shift distance. The integer shift operators never throw exceptions. You can overload the shift operators for user-defined structs/classes. There is no >>> operator as in Java, since C# has signed and unsigned types, (although the unsigned types are not part of the Common Language Specification CLS). There are no shift operators for shifting bytes or shorts. Shifting a byte/short will cause the byte/short to be converted to an int. This means the return type will be an int. This means, given b is a byte, the following will not compile: To solve this problem you can use an explicit conversion (a cast) or use the compound assignment form of the shift operator:

Integer to integer conversions are performed using explicit conversion operators (in other words; casts). Casts can be used in a checked expression:
    s = (short)m;            // 3
Statement 1 is always checked and if the value of m is outside the range of a short an OverflowException is throw. Statement 3 may or may not be checked (depending on the optional use of the /checked+ compilation flag). The top left table in the slide is the same in Java (except in Java the unsigned 8 bit integer is called byte and not sbyte)

C# supports two floating point types: float and double. There is no long double as in C/C++. Both types conform the the IEEE 754 formats: In C#, C++, and Java the suffix for float is F or f. In C#, as in Java, the suffix for double is D or d. In C++ there is no explicit suffix for doubles other than L or l for the long double type (which does not exist in C# or Java). As well as System.Single and System.Double there are other varieties of cream classes in the System namespace: Whipping, Pouring, Clotted, and Ice to name but four.

The keyword float is an alias for the System.Single struct type and the keyword double is an alias for the System.Double struct type. This means that when you write: If you use a using directive to make all types from the System namespace available you do not need to explicitly name the System prefix: There are a few typename keywords that share this property of only differing in the first letter: object à System.Object, string à System.String. You are recommended to use the keyword typename.

The literal 234F (which does not contain a decimal point) is legal in C#  and in Java but not in C or C++. Similarly the literal 234.F (which does contain a decimal point) is not legal in C# but is legal in C, C++, and Java. The fact that 234.F is not legal C# is due to potential grammatical ambiguities. Consider; 234 is a literal of type int and int which is an alias for System.Int32 which is a struct that declares fields and methods. Suppose System.Int32 declared an instance field called F. The syntax 234.F would then be ambiguous: is it a double literal with a type suffix or the F field being accessed through an int value? The compiler thinks the latter:    float f = 123.F; // compile time error. No F in 'int' There appears to be no way in C# to initialise a floating point literal other than in decimal radix (in Java you can convert a IEEE bit pattern contained in a long into a double using the Double.longBitsToDouble method.

You can use the % operator on floating point operands (you can in Java too, but not in C++). You cannot use the shift operators on floating point operands (you can't in Java or C++ either). Floating point operators never throw exceptions (this includes the assignment operator – remember the definite assignment rule). Instead in exceptional [sic] circumstances floating point operations produce zero, infinity, or NaN, as described below:

• Converting a double to a float requires a cast. The double value is first rounded to the nearest float value. If the double value is too small to represent as a float, the result becomes positive zero or negative zero. If the double value is too large to represent as a float, the result becomes positive infinity or negative infinity. If the double value is NaN the result is also NaN. • An integer to floating point conversion is always implicit and never requires a cast (although one may be used if desired). Conversions from int, uint, or long to float and from long to double may cause a loss of precision, but will never cause a loss of magnitude. The other implicit integer to floating point conversions never lose any information. • Conversion from a float or double to an integer type require an explicit cast. The source value is rounded to the nearest integral value, and this integral value becomes the result of the conversion. If the resulting integral value is outside the range of the destination type, an OverflowException is thrown. At least, that is the documented behaviour in the language specification. As at Beta 2 whether an OverflowException is actually thrown depends on the overflow checking context:

The char type represents an unsigned 16-bit integer with values between 0 and 65535. The set of possible values for the char type corresponds to the Unicode character set. Unicode consortium.
The Unicode Standard, Version 3.0.
Addison Wesley, Reading, Massachusetts,
2000.
ISBN 0-201-616335-5

System.Char is a struct that lives inside the System namespace. It realizes a number of interfaces (structs and inheritance are fully covered later):

A new-line terminal is defined as: a carriage return character (U+000D), a line feed character (U+000A), a carriage return character (U+000D) followed by line feed character (U+000A), a line separator character (U+2028), or a paragraph separator character (U+2029). In C# (as in Java) a character literal contains the representation of a single character (not true in C++!). A character that follows a backslash character must be one of the designated characters otherwise a compile time error occurs.

There are no implicit conversions from other types to the char type. In particular, even though the sbyte, byte, and short types have ranges that are fully representable using the char type, implicit conversions from sbyte, byte, or short to char do not exist.

An enum declaration defines the name, accessibility, underlying type, and members of the enum. The underlying type must be able to hold all the values of the named constants defined in the enum. The named constants defined in the enum are scoped inside the enum. In other words the following is not well-formed: Java does not have enums (not to be confused with Enumeration which is an interface). In Java enums have to be faked up using static readonly fields: C++ does have enums but the named constants do not require the name of the enum as a prefix.

Uniquely, a C# an enum type may explicitly declare its underlying type as sbyte, byte, short, ushort, int, uint, long, or ulong. An enum declaration that does not explicitly declare its underlying type defaults to an implicit underlying type of int. Named constants have the same type as the underlying type and must have a value in the range of the underlying type (for example, you cannot create a named constant with a negative value if the underlying type is explicitly declared as uint). If the named constant is not given an explicit constant value it defaults to the value of the previous named constant plus one (and the default value of the first named constant is zero). It is not an error for more than one named constant in the same enum declaration to have the same value. The initializer for a named constant cannot include itself either directly or indirectly and cannot refer to a following named constant (this would create a circular dependency and is one of the few cases of an order dependency in C#). The last named constant can be declared with a trailing comma. This makes it easy to add more named constants in the future, although if this is likely you should consider not using an enum! An enum is best suited to a fixed number of grouped names: you are extremely unlikely to need a fifth suit, or a thirteenth month, etc. Try and avoid explicitly initializing named constants. As a gesture to C++ programmers, an enum declaration is allowed an optional trailing semi-colon (it is in Java too). It's best to get out of the habit using a trailing semi-colon as it not perimtted on a function definition (it is in Java).

System.Enum is a class that lives inside the System namespace. It realizes a number of interfaces (classes and inheritance are fully covered later):
    public class Enum enum types (such as Suit) implicitly derive from System.Enum (as well as implicitly or explicitly deriving from their underlying type). Note that this is different to types as the System.Int32 struct which is an alias for int. C# has powerful introspection capabilities (introspection is the ability of a program to observe and reason about its own state). Unlike C++, C#  can easily print out the name of a enum variable. You can do this via the IFormattable interface: directly by calling the Format method or indirectly by using the "{0}" format string. Note that using the ToString method prints the value of the enum variable and not its name. System.Enum is a special class designed to be used only as an implicit base class of all enum types.

if value does not correspond to a named constant Format prints the value.

The basic syntax for declaring a C# constructor is the same as in Java and C++. The main difference is that C# constructors cannot declare a throw specification (since there are no throw specifications in C#). A struct will always have a compiler generated default constructor. If you don't declare a constructor for your struct the compiler generated default constructor exists. If you do declare a constructor for your struct the compiler generated default constructor still exists. This means that you cannot declare a user-defined default constructor for a struct (since then there would be two). Note that this rule does not apply to classes. The compiler generated default constructor zero initializes all instance fields of the object to zero: Note that the default accessibility of a struct and class constructor is private (as it is for fields). This is different to Java where the accessibility of the default constructor depends on the accessibility of the containing class. Note that in Java you can override the default constructor, and if you declare any constructor the compiler does not then generate the default constructor. Java also allows a method with the same name as a constructor (C# does not).

In C# a constructor can call a sibling constructor as shown on the slide. Note that in Java the syntax is subtley different; the chained call occurs inside the { body } The general member-initialization-list syntax available in C++ is not legal syntax in C#. There are no issues regarding a struct constructor calling a base class constructor since a struct cannot inherit from a class.

In C# a const field is implicit static. In Java a final field is not implicitly static. The first error is caused by attempting to initialize a const field in a constructor. A const field can only be initialized using the variable intialization syntax: The second error is caused by specifying the const int field with an explicit static modifier. A const field is implicitly static and can only be implicitly static. The third error is caused by failing to initialize the const field (which was erroneously attempted in the constructor). The fourth error is caused by attempting to qualify a field of type Pair with the const modifier. A const modifier can only be applied to simple types (the types with a keyword name and a literal syntax), enums, and strings. Pair cannot be any of these types since an enum cannot be initialized using new (the only value type that can't) and Pair cannot be an alias for a simple type or string since there are no typedef's in C#.

A field declared with the static modifier is called a static variable. A static variable comes into existence when the type in which it is declared is loaded, and ceases to exist when the program terminates. Remember, the static modifier cannot be applied to enum types or simple types. It can only be applied to user-defined struct types and class types. Note that since string is a class type (a reference type) it is possible to create a constant string using either syntax: Like Java, static fields can only be accessed using the name of the enclosing type (in C++ you can use the typename or a variable).

In Java you can write code a static initialisation block (or two or three...) in a class declaration and that code will be executed once when the class is loaded.  There is no equivalent of Java static initialisation blocks in C#. However, you can declare a single static constructor which serves the same purpose. A static constructor is called by the .NET VES and not by a programmer. This ensures that it is called, it is called only once, and it is called at the right time (before any use of the struct/class). Since the programmer does not call the static constructor the static constructor is not allowed any parameters. For the same reason the static constructor is not allowed to be qualified with a public, protected, private, or internal access modifier. why use a static constructor instead of a variable initializer? possibly to surround it with try block? would that work?

plain bitwise copy will never throw an exception

similarly you cannot change the behaviour that assignment does a simple bitwise copy.