Introduction
Hello world
The “Hello, World” program is traditionally used to introduce a programming language Here it is in C#: using System; class Hello
C# source files use the cs file extension, and for instance, a "Hello, World" program saved as hello.cs can be compiled using the Microsoft C# compiler with the command line instruction csc hello.cs This command generates an executable assembly named hello.exe, which produces output when the application is executed.
The "Hello, World" program begins with a using directive that points to the System namespace, which organizes C# programs and libraries hierarchically This namespace includes various types, such as the Console class, as well as other namespaces like IO and Collections By utilizing the using directive, the program allows for the unqualified use of types within that namespace, enabling the shorthand Console.WriteLine for outputting text.
The Hello class in the "Hello, World" program features a single member, the Main method, which is declared as static Unlike instance methods that can reference a specific object instance using the keyword this, static methods function independently of any particular object Conventionally, the static Main method acts as the program's entry point.
The output generated by the program is achieved through the WriteLine method of the Console class within the System namespace This class is part of the NET Framework class libraries, which are automatically referenced by the Microsoft C# compiler It's important to note that C# does not possess a distinct runtime library; rather, it utilizes the NET Framework as its runtime library.
Program structure
C# programming is built around essential organizational concepts, including programs, namespaces, types, members, and assemblies A C# program comprises one or more source files that declare types, such as classes and interfaces, which contain various members like fields, methods, properties, and events These types can be grouped into namespaces for better organization Upon compilation, C# programs are packaged into assemblies, which typically have the file extensions exe for applications or dll for libraries.
The example using System; namespace Acme.Collections
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; public Entry(Entry next, object data) { this.next = next; this.data = data;
The Stack class is defined within the Acme.Collections namespace, with its fully qualified name being Acme.Collections.Stack This class includes several members, such as a field called top, along with two methods, Push and Pop, and a nested Entry class The Entry class contains three members: a field named next, a field named data, and a constructor To compile the source code stored in the file acme.cs as a library, which does not require a Main entry point, the command line csc /t:library acme.cs is used, resulting in the creation of an assembly named acme.dll.
Assemblies consist of executable code represented as Intermediate Language (IL) instructions and metadata, which provides symbolic information Prior to execution, the IL code within an assembly is converted into processor-specific code by the Just-In-Time (JIT) compiler of the NET Common Language Runtime.
In C#, assemblies serve as self-describing units of functionality that encompass both code and metadata, eliminating the need for #include directives and header files By referencing an assembly during compilation, the public types and members it contains become accessible in a C# program For instance, the Acme.Collections.Stack class from the acme.dll assembly can be utilized in a program as follows: using System; using Acme.Collections; class Test.
Stack s = new Stack(); s.Push(1); s.Push(10); s.Push(100);
To compile the program stored in the file test.cs while referencing the acme.dll assembly, use the compiler's /r option with the following command: csc /r:acme.dll test.cs.
This creates an executable assembly named test.exe, which, when run, produces the output:
C# allows programs to be divided into multiple source files, enabling seamless inter-referencing among them during compilation, as if they were combined into a single file This eliminates the need for forward declarations, as the order of declarations is generally not important Additionally, C# does not restrict a source file to a single public type and does not mandate that the file name matches any declared type within it.
Types and variables
In C#, there are two primary categories of types: value types and reference types Value types directly hold their data, while reference types store references to objects containing the data This distinction allows reference types to enable multiple variables to reference the same object, meaning that changes made through one variable can impact the object referenced by another Conversely, value types maintain individual copies of their data, ensuring that operations on one variable do not influence another, except when using ref and out parameter variables.
C# categorizes its data types into two main groups: value types and reference types Value types are further classified into simple types, enum types, struct types, and nullable types In contrast, reference types encompass class types, interface types, array types, and delegate types.
The following table provides an overview of C#’s type system.
Simple types Signed integral: sbyte, short, int, long
Unsigned integral: byte, ushort, uint, ulong Unicode characters: char
IEEE floating point: float, double High-precision decimal: decimal Boolean: bool
Enum types User-defined types of the form enum E { }
Struct types User-defined types of the form struct S { }
Nullable types Extensions of all other value types with a null value
Class types Ultimate base class of all other types: object
Unicode strings: string User-defined types of the form classC{ }
Interface types User-defined types of the form interface I { }
Array types Single- and multi-dimensional, for example, int[] and int[,]
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.
Category Bits Type Range/Precision
64 double 5.0 × 10 −324 to 1.7 × 10 308 , 15-digit precision Decimal 128 decimal 1.0 × 10 −28 to 7.9 × 10 28 , 28-digit precision
C# allows developers to create new types through type declarations, which define the name and members of these types The language offers five user-definable categories: class types, struct types, interface types, enum types, and delegate types.
A class type is a data structure that encompasses data members, such as fields, and function members, including methods and properties It enables single inheritance and polymorphism, allowing derived classes to extend and specialize their base classes effectively.
A struct type, akin to a class type, represents a structure comprising data members and function members However, unlike classes, structs are value types that do not necessitate heap allocation Additionally, struct types do not allow for user-specified inheritance, as they implicitly inherit from the object type.
An interface type establishes a contract through a named collection of public function members, requiring any class or struct that implements it to provide specific implementations of those functions Additionally, an interface can inherit from multiple base interfaces, while a class or struct can implement several interfaces simultaneously.
A delegate type encapsulates references to methods with specific parameter lists and return types, allowing methods to be treated as first-class entities This enables the assignment of methods to variables and their use as parameters, enhancing flexibility in programming.
Delegates are similar to the concept of function pointers found in some other languages, but unlike function pointers, delegates are object-oriented and type-safe.
Class, struct, interface and delegate types all support generics, whereby they can be parameterized with other types.
An enum type is a unique data type that consists of named constants, with each enum type having a corresponding underlying type that must be one of the eight integral types The values defined by an enum type align precisely with the values of its underlying type.
C# allows the use of single- and multi-dimensional arrays for any data type without prior declaration Array types are defined by appending square brackets to a type name, such as int[] for a single-dimensional array, int[,] for a two-dimensional array, and int[][] for an array of single-dimensional arrays.
Nullable types can be used without prior declaration, and for every non-nullable value type T, there exists a corresponding nullable type T? that allows for an additional null value For example, the type int? can represent any 32-bit integer or the value null.
C# features a unified type system where every type, whether reference or value, can be treated as an object, as all types derive from the object class Reference types are inherently viewed as objects, while value types require boxing and unboxing to be treated as such For instance, an integer can be converted to an object and then back to an integer, demonstrating this flexibility in type handling.
{ static void Main() { int i = 123; object o = i; // Boxing int j = (int)o; // Unboxing }
When a value type is converted to an object type, a new object instance, known as a "box," is created to store the value, which is then copied into this box Conversely, when casting an object reference back to a value type, the system verifies that the object is indeed a box containing the correct value type, and if the verification passes, the value is extracted from the box.
C# features a unified type system that allows value types to function as objects when needed This unification enables general-purpose libraries that utilize type objects to seamlessly work with both reference types and value types, enhancing flexibility in programming.
In C#, variables come in various forms, such as fields, array elements, local variables, and parameters Each variable serves as a storage location, and its type dictates the values that can be stored within it, as illustrated in the accompanying table.
Type of Variable Possible Contents
A value of that exact type
A nullable value type can represent either a null value or a specific value of that type In contrast, a null reference denotes a reference to an object of any reference type or a boxed value of any value type.
Class type A null reference, a reference to an instance of that class type, or a reference to an instance of a class derived from that class type
Interface type A null reference, a reference to an instance of a class type that implements that interface type, or a reference to a boxed value of a value type that implements that interface type
Expressions
Expressions consist of operands and operators, where operators dictate the operations performed on the operands Common operators include +, -, *, /, and new, while operands can be literals, fields, local variables, or other expressions.
In expressions with multiple operators, the order of evaluation is determined by operator precedence For instance, in the expression x + y * z, the operation is performed as x + (y * z), prioritizing the multiplication over addition.
* operator has higher precedence than the + operator.
Operator overloading allows developers to define custom implementations for operators when dealing with user-defined classes or structs, enabling more intuitive interactions with these types This feature is essential for enhancing the functionality of operators, as it permits operators to be tailored to work seamlessly with specific data types.
The following table summarizes C#’s operators, listing the operator categories in order of precedence from highest to lowest Operators in the same category have equal precedence.
The article covers various programming concepts, including primary member access, method and delegate invocation, and array and indexer access It discusses post-increment and post-decrement operators, as well as object and delegate creation using both standard and initializer syntax Additionally, it highlights the creation of anonymous objects and arrays, obtaining the System.Type object for a given type, and evaluating expressions in both checked and unchecked contexts Finally, it touches on obtaining default values for types and the use of anonymous functions, also known as anonymous methods.
Additive x + y Addition, string concatenation, delegate combination x – y Subtraction, delegate removal
Shift x > y Shift right
Relational and type testing involves various comparisons: "x < y" signifies that x is less than y, while "x > y" indicates that x is greater than y The expressions "x = y" represent less than or equal to, and greater than or equal to, respectively The function "x is T" returns true if x is of type T, and false otherwise Additionally, "x as T" casts x to type T, returning null if x does not conform to type T.
Logical AND x & y Integer bitwise AND, boolean logical AND
Logical XOR x ^ y Integer bitwise XOR, boolean logical XOR
Logical OR x | y Integer bitwise OR, boolean logical OR
Conditional AND x && y Evaluates y only if x is true
Conditional OR x || y Evaluates y only if x is false
Null coalescing X ?? y Evaluates to y if x is null, to x otherwise
Conditional x ? y : z Evaluates y if x is true, z if x is false
Assignment or anonymous function x = y Assignment x op= y Compound assignment; supported operators are
Statements
The actions of a program are expressed using statements C# supports several different kinds of statements, a number of which are defined in terms of embedded statements.
A block permits multiple statements to be written in contexts where a single statement is allowed A block consists of a list of statements written between the delimiters { and }.
Declaration statements are used to declare local variables and constants.
Expression statements evaluate various expressions, including method invocations, object allocations with the new operator, and assignments using the equals sign and compound assignment operators Additionally, they encompass increment and decrement operations through the use of the ++ and operators.
Selection statements, including if and switch statements, are utilized to determine which statement to execute from multiple options based on the value of a given expression.
Iteration statements are used to repeatedly execute an embedded statement In this group are the while, do, for,and foreach statements.
Jump statements are used to transfer control In this group are the break, continue, goto, throw, return, and yield statements.
The try catch statement is designed to handle exceptions that arise during the execution of a code block, while the try finally statement ensures that finalization code runs regardless of whether an exception was thrown.
The checked and unchecked statements are used to control the overflow checking context for integral-type arithmetic operations and conversions.
The lock statement is used to obtain the mutual-exclusion lock for a given object, execute a statement, and then release the lock.
The using statement is used to obtain a resource, execute a statement, and then dispose of that resource.
The following table lists C#’s statements and provides an example for each one.
Local variable declaration static void Main() { int a; int b = 2, c = 3; a = 1;
Local constant declaration static void Main() { const float pi = 3.1415927f; const int r = 25;
Expression statement static void Main() { int i; i = 123; // Expression statement
Console.WriteLine(i); // Expression statement i++; // Expression statement
Console.WriteLine(i); // Expression statement } if statement static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("No arguments");
} else { Console.WriteLine("One or more arguments");
}} switch statement static void Main(string[] args) { int n = args.Length; switch (n) { case 0:
Console.WriteLine("No arguments"); break; case 1:
Console.WriteLine("One argument"); break; default:
} } } while statement static void Main(string[] args) { int i = 0; while (i < args.Length) { Console.WriteLine(args[i]); i++;
} } do statement static void Main() { string s; do { s = Console.ReadLine(); if (s != null) Console.WriteLine(s);
} for statement static void Main(string[] args) { for (int i = 0; i < args.Length; i++) { Console.WriteLine(args[i]);
} } foreach statement static void Main(string[] args) { foreach (string s in args) { Console.WriteLine(s);
} } break statement static void Main() { while (true) { string s = Console.ReadLine(); if (s == null) break;
} } continue statement static void Main(string[] args) { for (int i = 0; i < args.Length; i++) { if (args[i].StartsWith("/")) continue;
} goto statement static void Main(string[] args) { int i = 0; goto check; loop:
Console.WriteLine(args[i++]); check: if (i < args.Length) goto loop;
} return statement static int Add(int a, int b) { return a + b;
} static void Main() { Console.WriteLine(Add(1, 2)); return;
} yield statement static IEnumerable Range(int from, int to) { for (int i = from; i < to; i++) { yield return i;
} static void Main() { foreach (int x in Range(-10,10)) { Console.WriteLine(x);
} } throw and try statements static double Divide(double x, double y) { if (y == 0) throw new DivideByZeroException(); return x / y;
} static void Main(string[] args) { try { if (args.Length != 2) { throw new Exception("Two numbers required");
} double x = double.Parse(args[0]); double y = double.Parse(args[1]);
} catch (Exception e) { Console.WriteLine(e.Message);
} finally { Console.WriteLine(“Good bye!”);
} } checked and unchecked statements static void Main() { int i = int.MaxValue; checked {Console.WriteLine(i + 1); // Exception} unchecked { Console.WriteLine(i + 1); // Overflow }
{ decimal balance; public void Withdraw(decimal amount) { lock (this) { if (amount > balance) { throw new Exception("Insufficient funds");
} } } using statement static void Main() { using (TextWriter w = File.CreateText("test.txt")) { w.WriteLine("Line one"); w.WriteLine("Line two"); w.WriteLine("Line three");
Classes and objects
Classes are the core building blocks of C#, serving as data structures that unify state (fields) and behavior (methods) They define templates for creating objects, allowing for dynamic instance generation Additionally, classes enable inheritance and polymorphism, which allow derived classes to enhance and customize the functionality of base classes.
Class declarations are used to create new classes, beginning with a header that outlines the class's attributes, modifiers, name, any base class, and implemented interfaces Following this header, the class body contains member declarations enclosed within curly braces { }.
The following is a declaration of a simple class named Point: public class Point
{ public int x, y; public Point(int x, int y) { this.x = x; this.y = y;
Instances of classes are generated using the new operator, which allocates memory for the instance, calls a constructor for initialization, and returns a reference to the newly created object For example, two Point objects can be created and their references stored in separate variables.
The memory occupied by an object is automatically reclaimed when the object is no longer in use It is neither necessary nor possible to explicitly deallocate objects in C#.
The members of a class are either static members or instance members Static members belong to classes, and instance members belong to objects (instances of classes).
The following table provides an overview of the kinds of members a class can contain.
Constants Constant values associated with the class
Fields Variables of the class
Methods Computations and actions that can be performed by the class
Properties Actions associated with reading and writing named properties of the class
Indexers Actions associated with indexing instances of the class like an array
Events Notifications that can be generated by the class
Operators Conversions and expression operators supported by the class
Constructors Actions required to initialize instances of the class or the class itself
Destructors Actions to perform before instances of the class are permanently discarded
Types Nested types declared by the class
Each class member has a defined accessibility level that regulates which parts of the program can access that member There are five distinct forms of accessibility available, which are outlined in the accompanying table.
Accessibility refers to the different levels of access control in programming Public access allows unrestricted access to all users, while protected access is limited to the class itself and its derived classes Internal access restricts visibility to the program, and protected internal access combines both, permitting access within the program and its derived classes Lastly, private access is the most restrictive, allowing access solely within the defining class.
A class definition can include type parameters by placing them in angle brackets after the class name, allowing these parameters to be utilized within the class's body to define its members For instance, in the example of the Pair class, the type parameters are designated as TFirst and TSecond: `public class Pair`.
{ public TFirst First; public TSecond Second;
A class type that is declared to take type parameters is called a generic class type Struct, interface and delegate types can also be generic.
When the generic class is used, type arguments must be provided for each of the type parameters:
Pair pair = new Pair { First = 1, Second = “two” }; int i = pair.First; // TFirst is int string s = pair.Second; // TSecond is string
A generic type with type arguments provided, like Pair above, is called a constructed type.
A class declaration can indicate a base class by placing a colon after the class name and type parameters, followed by the base class name If a base class is not specified, it defaults to deriving from the type object For instance, in the example provided, the Point3D class derives from the Point class, while the Point class itself derives from the object class.
{ public int x, y; public Point(int x, int y) { this.x = x; this.y = y;
{ public int z; public Point3D(int x, int y, int z): base(x, y) { this.z = z;
Inheritance in object-oriented programming allows a derived class to implicitly include all members of its base class, excluding the base class's constructors While a derived class can introduce new members, it cannot eliminate inherited members For instance, in the example of Point3D, it inherits the x and y fields from the Point class, resulting in each Point3D instance containing three fields: x, y, and z.
An implicit conversion allows a variable of a class type to reference instances of its own class or any derived class For instance, a variable of type Point can reference both a Point instance and a Point3D instance.
A field is a variable that is associated with a class or with an instance of a class.
A static field, defined by the static modifier, represents a single storage location within a class Regardless of the number of class instances created, only one copy of the static field exists, ensuring consistent access across all instances.
A field declared without the static modifier defines an instance field Every instance of a class contains a separate copy of all the instance fields of that class.
In the Color class example, each instance possesses its own unique r, g, and b instance fields, while the static fields for Black, White, Red, Green, and Blue are shared among all instances.
In the provided code, several color constants are defined, including Black, White, Red, Green, and Blue, each represented by their RGB values The Color class is constructed with three private byte variables for red, green, and blue components, allowing for the creation of custom colors.
Read-only fields can be defined using the readonly modifier, allowing assignment only during the field's declaration or within a constructor of the same class.
A method is a member that implements a computation or action that can be performed by an object or class
Static methods are accessed through the class Instance methods are accessed through instances of the class.
Methods consist of a list of parameters, which may be empty, representing the values or variable references provided to the method They also have a return type that indicates the type of value the method computes and returns If a method does not return a value, its return type is designated as void.
Methods, similar to types, can include type parameters that require specific type arguments during invocation However, unlike types, these type arguments are frequently inferred from the method call's arguments, eliminating the need for explicit specification.
Structs
Structs, similar to classes, are data structures that encompass data members and function members; however, they are value types that do not necessitate heap allocation A struct variable directly holds the struct's data, while a class variable contains a reference to a dynamically allocated object Unlike classes, structs do not allow user-defined inheritance, as all struct types inherently inherit from the object type.
Structs are ideal for small data structures that exhibit value semantics, such as complex numbers, coordinate points, and key-value pairs in dictionaries Opting for structs instead of classes for these small data structures can significantly reduce the number of memory allocations in an application For instance, when implementing a program that creates and initializes an array of 100 points, using a class for Point results in the instantiation of 101 separate objects—one for the array and one for each of the 100 elements.
{ public int x, y; public Point(int x, int y) { this.x = x; this.y = y;
Point[] points = new Point[100]; for (int i = 0; i < 100; i++) points[i] = new Point(i, i);
An alternative is to make Point a struct. struct Point
{ public int x, y; public Point(int x, int y) { this.x = x; this.y = y;
Now, only one object is instantiated—the one for the array—and the Point instances are stored in-line in the array.
Struct constructors use the new operator for invocation, but this does not necessarily mean memory allocation occurs Rather than dynamically allocating an object and providing a reference, a struct constructor returns the struct value itself, usually stored temporarily on the stack, which is then copied as needed.
In programming, classes allow multiple variables to reference the same object, meaning changes made through one variable can impact the object referenced by another In contrast, structs provide each variable with its own copy of the data, ensuring that operations on one do not influence the other The distinction between classes and structs is crucial, as demonstrated by the varying outputs produced by code fragments depending on whether Point is defined as a class or a struct.
If Point is a class, the output is 20 because a and b reference the same object If Point is a struct, the output is
10 because the assignment of a to b creates a copy of the value, and this copy is unaffected by the subsequent assignment to a.x.
Structs have notable limitations, including lower efficiency in copying entire structs compared to object references, making assignment and value parameter passing more costly Additionally, the inability to create references to structs, except when using ref and out parameters, restricts their applicability in various scenarios.
Arrays
An array is a data structure that holds multiple variables, accessible via computed indices All variables within an array, known as its elements, share the same data type, referred to as the element type of the array.
Array types are reference types, meaning that declaring an array variable allocates space for a reference to an array instance rather than the array itself Actual array instances are created dynamically at runtime using the new operator, which also defines the length of the array, a value that remains fixed for the instance's lifetime The indices of an array's elements range from 0 to Length-1, and the new operator automatically initializes the elements to their default values—zero for numeric types and null for reference types.
The following example creates an array of int elements, initializes the array, and prints out the contents of the array. using System; class Test
{ static void Main() { int[] a = new int[10]; for (int i = 0; i < a.Length; i++) { a[i] = i * i;
} for (int i = 0; i < a.Length; i++) { Console.WriteLine("a[{0}] = {1}", i, a[i]);
C# supports both single-dimensional and multi-dimensional arrays, with the rank of an array type determined by the number of commas between the square brackets For example, a one-dimensional array can be created using `int[] a1 = new int[10];`, while a two-dimensional array is defined as `int[,] a2 = new int[10, 5];`, and a three-dimensional array is represented by `int[,,] a3 = new int[10, 5, 2];`.
The a1 array contains 10 elements, the a2 array contains 50 (10 × 5) elements, and the a3 array contains 100
An array can contain elements of any type, including other arrays, which leads to the concept of jagged arrays Jagged arrays are characterized by their element arrays having varying lengths For instance, an example of allocating a jagged array of integers is as follows: `int[][] a = new int[3][]; a[0] = new int[10]; a[1] = new int[5]; a[2] = new int[20];`.
The code initializes an array containing three elements of type int[], all set to null initially Following this, each element is assigned a reference to distinct array instances, each with different lengths.
The new operator allows for the initialization of array elements using an array initializer, which consists of a list of expressions enclosed in curly braces { } For instance, the code snippet `int[] a = new int[] {1, 2, 3};` demonstrates how to allocate and initialize an integer array with three elements.
In programming, the length of an array is determined by the number of elements enclosed within curly braces Additionally, local variable and field declarations can be simplified, eliminating the need to repeatedly specify the array type For example, the declaration `int[] a = {1, 2, 3};` demonstrates this concise syntax.
Both of the previous examples are equivalent to the following: int[] t = new int[3]; t[0] = 1; t[1] = 2; t[2] = 3; int[] a = t;
Interfaces
An interface establishes a contract for classes and structs to follow, encompassing methods, properties, events, and indexers It does not provide implementations for its members; instead, it outlines the required members that implementing classes or structs must provide.
Interfaces may employ multiple inheritance In the following example, the interface IComboBox inherits from both ITextBox and IListBox. interface IControl
Classes and structs can implement multiple interfaces In the following example, the class EditBox implements both IControl and IDataBound. interface IDataBound
} public class EditBox: IControl, IDataBound
{ public void Paint() { } public void Bind(Binder b) { }
When a class or struct implements a particular interface, instances of that class or struct can be implicitly converted to that interface type For example
Dynamic type casts can be utilized when the implementation of a specific interface is not statically known For instance, the following statements demonstrate how to use dynamic type casts to retrieve an object's IControl.
IDataBound interface implementations Because the actual type of the object is EditBox, the casts succeed. object obj = new EditBox();
In the EditBox class, the Paint method from the IControl interface and the Bind method from the IDataBound interface are implemented as public members However, C# allows for explicit interface member implementations, enabling classes or structs to keep these members non-public This is achieved by using the fully qualified interface member name for implementation For instance, the EditBox class can implement the IControl.Paint and IDataBound.Bind methods through explicit interface member implementations.
{ void IControl.Paint() { } void IDataBound.Bind(Binder b) { }
Explicit interface members are accessible solely through the interface type For instance, to invoke the IControl.Paint method implemented by the EditBox class, one must first cast the EditBox reference to the IControl interface type.
EditBox editBox = new EditBox(); editBox.Paint(); // Error, no such method
IControl control = editBox; control.Paint(); // Ok
Enums
An enum type is a unique value type that consists of a collection of named constants For instance, in C#, an enum type called Color can be defined with three constant values: Red, Green, and Blue.
{ static void PrintColor(Color color) { switch (color) { case Color.Red:
Console.WriteLine("Red"); break; case Color.Green:
Console.WriteLine("Green"); break; case Color.Blue:
Console.WriteLine("Blue"); break; default:
Console.WriteLine("Unknown color"); break;
Each enum type is associated with an underlying integral type, which defaults to int if not explicitly specified The underlying type dictates the storage format and range of values for the enum Notably, the possible values of an enum type extend beyond its defined members, allowing any value of the underlying type to be cast to the enum, thus creating a distinct valid value within that enum type.
The following example declares an enum type named Alignment with an underlying type of sbyte. enum Alignment: sbyte
An enum member declaration can include a constant expression to define its value, which must fall within the range of the enum's underlying type If a value is not explicitly specified for an enum member, it automatically receives a value of zero if it is the first member, or it takes the value of the preceding enum member plus one.
Enum values can be converted to integral values and vice versa using type casts For example int i = (int)Color.Blue; // int i = 2;
Color c = (Color)2; // Color c = Color.Blue;
The default value for any enum type is the integral value zero, which is converted to the respective enum type When variables are automatically initialized, they receive this default value To ensure easy access to the default value, the literal 0 can be implicitly converted to any enum type, allowing for straightforward usage.
Delegates
A delegate type allows for the representation of references to methods with specific parameter lists and return types By using delegates, methods can be treated as first-class entities, enabling them to be assigned to variables and passed as parameters seamlessly.
Delegates are similar to the concept of function pointers found in some other languages, but unlike function pointers, delegates are object-oriented and type-safe.
The following example declares and uses a delegate type named Function. using System; delegate double Function(double x); class Multiplier
{ double factor; public Multiplier(double factor) { this.factor = factor;
} public double Multiply(double x) { return x * factor;
{ static double Square(double x) { return x * x;
} static double[] Apply(double[] a, Function f) { double[] result = new double[a.Length]; for (int i = 0; i < a.Length; i++) result[i] = f(a[i]); return result;
} static void Main() { double[] a = {0.0, 0.5, 1.0}; double[] squares = Apply(a, Square); double[] sines = Apply(a, Math.Sin);
Multiplier m = new Multiplier(2.0); double[] doubles = Apply(a, m.Multiply);
The Function delegate type can reference any method that accepts a double argument and returns a double value The Apply method utilizes a specified Function to process elements of a double array, resulting in a new double array containing the outcomes In the Main method, the Apply function demonstrates its versatility by applying three distinct functions to a double array.
A delegate can point to either a static method, like Square or Math.Sin, or an instance method, such as m.Multiply When a delegate references an instance method, it is tied to a specific object, making that object the context for the invocation when the method is called through the delegate.
Delegates can be created with anonymous functions, which are inline methods generated on the fly These anonymous functions have access to the local variables of their surrounding methods, allowing for simpler code For example, the multiplier functionality can be easily implemented without a separate Multiplier class by using a concise syntax: double[] doubles = Apply(a, (double x) => x * 2.0);
A key feature of a delegate is its independence from the class of the method it references; what is essential is that the method matches the delegate's parameters and return type.
Attributes
In C#, various types and members utilize modifiers to regulate their behavior, particularly in terms of accessibility through keywords like public, protected, internal, and private Additionally, C# allows for user-defined types of declarative information to be associated with program entities, which can be accessed at runtime This is achieved by defining and employing attributes, enabling programmers to specify extra metadata within their applications.
The following example declares a HelpAttribute attribute that can be placed on program entities to provide links to their associated documentation. using System; public class HelpAttribute: Attribute
{ string url; string topic; public HelpAttribute(string url) { this.url = url;
} public string Url { get { return url; } } public string Topic { get { return topic; } set { topic = value; } }
In the NET Framework, all attribute classes inherit from the System.Attribute base class Attributes are applied by placing their name and any arguments within square brackets before the relevant declaration Notably, when referencing an attribute whose name ends with "Attribute," this suffix can be omitted For instance, the HelpAttribute can be referenced simply as Help.
[Help("http://msdn.microsoft.com/ /MyClass.htm")] public class Widget
[Help("http://msdn.microsoft.com/ /MyClass.htm", Topic = "Display")] public void Display(string text) {}
In this example, a HelpAttribute is applied to both the Widget class and its Display method The public constructors of the attribute class dictate the necessary information required when the attribute is associated with a program entity Furthermore, additional details can be supplied through the public read-write properties of the attribute class, such as the Topic property reference mentioned earlier.
The following example shows how attribute information for a given program entity can be retrieved at runtime using reflection. using System; using System.Reflection; class Test
{ static void ShowHelp(MemberInfo member) {
HelpAttribute a = Attribute.GetCustomAttribute(member, typeof(HelpAttribute)) as HelpAttribute; if (a == null) { Console.WriteLine("No help for {0}", member);
} else { Console.WriteLine("Help for {0}:", member);
Console.WriteLine(" Url={0}, Topic={1}", a.Url, a.Topic);
ShowHelp(typeof(Widget).GetMethod("Display"));
When an attribute is requested via reflection, the constructor of the attribute class is called with the relevant information from the source code, resulting in the creation of an attribute instance If any additional information is supplied through properties, those properties are assigned the specified values before the attribute instance is returned.
Lexical structure
Programs
A C# program is made up of one or more source files, also referred to as compilation units These source files consist of an ordered sequence of Unicode characters and usually correspond one-to-one with files in a file system, although this is not a strict requirement To ensure maximal portability, it is advisable to encode these files using UTF-8 encoding.
Conceptually speaking, a program is compiled using three steps:
1 Transformation, which converts a file from a particular character repertoire and encoding scheme into a sequence of Unicode characters.
2 Lexical analysis, which translates a stream of Unicode input characters into a stream of tokens
3 Syntactic analysis, which translates the stream of tokens into executable code.
Grammars
This specification outlines the C# programming language syntax through two grammars The lexical grammar details the combination of Unicode characters into line terminators, white space, comments, tokens, and pre-processing directives Meanwhile, the syntactic grammar describes how these tokens are assembled to create C# programs.
Lexical and syntactic grammars are defined through grammar productions, which specify a non-terminal symbol and its potential expansions into sequences of both non-terminal and terminal symbols In these productions, non-terminal symbols are italicized, while terminal symbols are presented in a fixed-width font.
In grammar production, the definition begins with the non-terminal symbol followed by a colon Subsequent indented lines outline potential expansions of the non-terminal, consisting of sequences of non-terminal or terminal symbols For instance, the production for a while-statement specifies that it includes the token "while," followed by "(", a boolean-expression, ")", and an embedded-statement.
When multiple expansions of a non-terminal symbol exist, they are presented on separate lines For instance, the production "statement-list: statement statement-list statement" indicates that a statement list can be formed by either a single statement or a combination of a statement-list followed by a statement This recursive definition clarifies that a statement list comprises one or more statements.
A subscripted suffix “ opt ” is used to indicate an optional symbol The production: block:
{ statement-list opt } is shorthand for: block:
{ statement-list } and defines a block to consist of an optional statement-list enclosed in “{” and “}” tokens.
Alternatives are normally listed on separate lines, though in cases where there are many alternatives, the phrase
The phrase "one of" can introduce a list of options presented in a single line, serving as a concise way to indicate that each alternative can be expanded upon separately For instance, in the context of production, it might appear as: real-type-suffix: one of.
F f D d M m is shorthand for: real-type-suffix:
The lexical grammar of C# is detailed in sections §2.3, §2.4, and §2.5, outlining the use of Unicode character set symbols It defines the combination of characters to create tokens, manage white space, handle comments, and process directives.
Every source file in a C# program must conform to the input production of the lexical grammar (§2.3).
The syntactic grammar of C# is detailed in the subsequent chapters and appendices, outlining how tokens—defined by the lexical grammar—are combined to create C# programs.
Every source file in a C# program must conform to the compilation-unit production of the syntactic grammar (§9.1).
Lexical analysis
The input production establishes the lexical structure of a C# source file, which must adhere to specific lexical grammar rules Each C# source file consists of an input section that may include optional elements, followed by input section parts These parts contain input elements, which can be interspersed with whitespace, comments, and tokens, ensuring the correct format and organization of the code.
A C# source file is composed of five essential elements: line terminators, white space, comments, tokens, and pre-processing directives Among these, only tokens play a crucial role in the syntactic grammar of a C# program.
Lexical processing of a C# source file involves transforming the file into a sequence of tokens that serve as input for syntactic analysis Tokens can be separated by line terminators, white space, and comments, while pre-processing directives may lead to the omission of certain sections of the source file However, these lexical elements do not influence the syntactic structure of a C# program.
In lexical processing, when multiple grammar productions correspond to a character sequence in a source file, the system prioritizes forming the longest possible lexical element For instance, the character sequence "//" is recognized as the start of a single-line comment, as it constitutes a longer lexical element than a single "/" token.
Line terminators divide the characters of a C# source file into lines. new-line:
Carriage return character (U+000D) followed by line feed character (U+000A)
To ensure compatibility with source code editing tools that insert end-of-file markers and to allow source files to be displayed as a sequence of properly terminated lines, specific transformations are systematically applied to every source file in a C# program.
• If the last character of the source file is a Control-Z character (U+001A), this character is deleted.
If a source file is non-empty and does not end with a carriage return (U+000D), line feed (U+000A), line separator (U+2028), or paragraph separator (U+2029), a carriage-return character (U+000D) will be appended to the end of the file.
The article discusses two types of comments in programming: single-line comments and delimited comments Single-line comments begin with "//" and continue until the end of the line, while delimited comments are enclosed within "/*" and "*/" and can extend across multiple lines This allows for flexibility in adding notes and explanations within the code.
// input-characters opt input-characters: input-character input-characters input-character input-character:
Any Unicode character except a new-line-character new-line-character:
Paragraph separator character (U+2029) delimited-comment:
/* delimited-comment-text opt asterisks / delimited-comment-text: delimited-comment-section delimited-comment-text delimited-comment-section delimited-comment-section:
/ asterisks opt not-slash-or-asterisk asterisks:
* asterisks * not-slash-or-asterisk:
Any Unicode character except / or *
Comments do not nest The character sequences /* and */ have no special meaning within a // comment, and the character sequences // and /* have no special meaning within a delimited comment.
Comments are not processed within character and string literals.
This program writes “hello, world” to the console
System.Console.WriteLine("hello, world");
// This program writes “hello, world” to the console
// class Hello // any name will do for this class
{ static void Main() { // this method must be named "Main"
System.Console.WriteLine("hello, world");
} shows several single-line comments.
White space refers to any character classified under Unicode as Zs, which encompasses the space character, horizontal tab, vertical tab, and form feed characters.
Any character with Unicode class Zs
Tokens
Tokens in programming can be categorized into several types, including identifiers, keywords, literals (such as integer, real, character, and string literals), and operators or punctuators It's important to note that white space and comments are not considered tokens; instead, they serve as separators that help organize these tokens.
A Unicode character escape sequence is a representation of a Unicode character that is utilized in identifiers, character literals, and regular string literals However, it is important to note that Unicode character escapes are not processed in other contexts, such as forming operators, punctuators, or keywords.
\u hex-digit hex-digit hex-digit hex-digit
\U hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit hex-digit
A Unicode escape sequence denotes a single Unicode character, indicated by a hexadecimal number following the “\u” or “\U” prefix In C#, Unicode code points are encoded using 16 bits, which restricts character literals to a range below U+10000 Characters within the range U+10000 to U+10FFFF must be represented using a Unicode surrogate pair in string literals Additionally, Unicode characters with code points exceeding 0x10FFFF are unsupported.
Multiple translations are not performed For instance, the string literal “\u005Cu005C” is equivalent to
“\u005C” rather than “\” The Unicode value \u005C is the character “\”.
{ static void Test(bool \u0066) { char c = '\u0066'; if (\u0066) System.Console.WriteLine(c.ToString());
} shows several uses of \u0066, which is the escape sequence for the letter “f” The program is equivalent to class Class1
{ static void Test(bool f) { char c = 'f'; if (f) System.Console.WriteLine(c.ToString());
The identifier rules outlined here align with the Unicode Standard Annex 15, with a few exceptions: underscores can be used as the initial character, which is a convention from the C programming language; Unicode escape sequences are permitted; and the "@" character can serve as a prefix, allowing keywords to function as identifiers An example of a valid identifier is "available-identifier."
@ identifier-or-keyword available-identifier:
An identifier-or-keyword that is not a keyword identifier-or-keyword: identifier-start-character identifier-part-characters opt identifier-start-character: letter-character
The underscore character (U+005F) is classified as an identifier-part-character, which includes various types of characters such as letter characters, decimal digit characters, connecting characters, combining characters, and formatting characters These elements collectively form the structure of identifiers in programming and markup languages.
A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
A unicode-escape-sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl combining-character:
A Unicode character of classes Mn or Mc
A unicode-escape-sequence representing a character of classes Mn or Mc decimal-digit-character:
A Unicode character of the class Nd
A unicode-escape-sequence representing a character of the class Nd connecting-character:
A Unicode character of the class Pc
A unicode-escape-sequence representing a character of the class Pc formatting-character:
A Unicode character of the class Cf
A unicode-escape-sequence representing a character of the class Cf
For information on the Unicode character classes mentioned above, see The Unicode Standard, Version 3.0, section 4.5.
Examples of valid identifiers include “identifier1”, “_identifier2”, and “@if”.
An identifier in a conforming program must be in the canonical format defined by Unicode Normalization Form
C, as defined by Unicode Standard Annex 15 The behavior when encountering an identifier not in
Normalization Form C is implementation-defined; however, a diagnostic is not required.
The "@" prefix allows keywords to function as identifiers, facilitating interactions with other programming languages Although the "@" character is not included in the identifier itself, it may appear as a standard identifier in other languages Identifiers prefixed with "@" are known as verbatim identifiers While it is technically acceptable to use the "@" prefix for non-keyword identifiers, it is generally advised against for stylistic reasons.
{ public static void @static(bool @bool) { if (@bool) System.Console.WriteLine("true"); else System.Console.WriteLine("false");
{ static void M() { cl\u0061ss.st\u0061tic(true);
The article discusses a class called "class" that includes a static method named "static," which accepts a parameter labeled "bool." It highlights that Unicode escapes cannot be used in keywords, meaning that "cl\u0061ss" is treated as an identifier, equivalent to "@class."
Two identifiers are considered the same if they are identical after the following transformations are applied, in order:
• The prefix “@”, if used, is removed.
• Each unicode-escape-sequence is transformed into its corresponding Unicode character.
• Any formatting-characters are removed.
Identifiers containing two consecutive underscore characters (U+005F) are reserved for use by the implementation For example, an implementation might provide extended keywords that begin with two underscores.
Keywords are reserved sequences of characters in programming that serve as identifiers, but can only be used when prefixed by the @ symbol Examples of keywords include abstract, bool, break, byte, case, catch, char, checked, class, const, continue, decimal, default, delegate, do, double, else, enum, event, explicit, extern, false, finally, fixed, float, for, foreach, goto, if, implicit, in, int, interface, internal, is, lock, long, namespace, new, null, object, operator, out, override, params, private, protected, public, readonly, ref, return, sbyte, sealed, short, sizeof, stackalloc, static, string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, volatile, while.
In certain areas of grammar, specific identifiers hold unique significance without being classified as keywords For instance, in property declarations, the identifiers "get" and "set" possess distinct meanings and cannot be replaced by other identifiers This ensures that their usage in these contexts does not interfere with their role as identifiers elsewhere.
A literal is a source code representation of a value. literal: boolean-literal integer-literal real-literal character-literal string-literal null-literal
There are two boolean literal values: true and false. boolean-literal: true false
The type of a boolean-literal is bool.
Integer literals represent values for the data types int, uint, long, and ulong, and can be expressed in two formats: decimal and hexadecimal A decimal integer literal consists of decimal digits followed optionally by an integer type suffix, while a hexadecimal integer literal is defined using a specific prefix Understanding these formats is essential for proper data representation in programming.
0 1 2 3 4 5 6 7 8 9 integer-type-suffix: one of
U u L l UL Ul uL ul LU Lu lU lu hexadecimal-integer-literal:
0x hex-digits integer-type-suffix opt
0X hex-digits integer-type-suffix opt hex-digits: hex-digit hex-digits hex-digit hex-digit: one of
The type of an integer literal is determined as follows:
• If the literal has no suffix, it has the first of these types in which its value can be represented: int, uint, long, ulong.
• If the literal is suffixed by U or u, it has the first of these types in which its value can be represented: uint, ulong.
• If the literal is suffixed by L or l, it has the first of these types in which its value can be represented: long, ulong.
• If the literal is suffixed by UL, Ul, uL, ul, LU, Lu, lU, or lu, it is of type ulong.
If the value represented by an integer literal is outside the range of the ulong type, a compile-time error occurs.
As a matter of style, it is suggested that “L” be used instead of “l” when writing literals of type long, since it is easy to confuse the letter “l” with the digit “1”.
To permit the smallest possible int and long values to be written as decimal integer literals, the following two rules exist:
When a decimal integer literal valued at 2147483648 (2^31) is preceded by a unary minus operator and lacks an integer type suffix, it results in a constant of type int with a value of −2147483648 (−2^31) In contrast, in all other cases, this decimal integer literal is classified as type uint.
When a decimal-integer-literal valued at 9223372036854775808 (2^63) is used immediately after a unary minus operator and lacks an integer-type suffix (L or l), it results in a constant of type long with a value of −9223372036854775808 (−2^63) In all other cases, this decimal-integer-literal is classified as type ulong.
Real literals are used to write values of types float, double, and decimal. real-literal: decimal-digits decimal-digits exponent-part opt real-type-suffix opt
decimal-digits exponent-part opt real-type-suffix opt decimal-digits exponent-part real-type-suffix opt decimal-digits real-type-suffix exponent-part: e sign opt decimal-digits
E sign opt decimal-digits sign: one of
+ - real-type-suffix: one of
If no real-type-suffix is specified, the type of the real literal is double Otherwise, the real type suffix determines the type of the real literal, as follows:
• A real literal suffixed by F or f is of type float For example, the literals 1f, 1.5f, 1e10f, and 123.456F are all of type float.
• A real literal suffixed by D or d is of type double For example, the literals 1d, 1.5d, 1e10d, and
123.456D are all of type double.
A real literal suffixed with "M" or "m" denotes a decimal type, such as 1m, 1.5m, 1e10m, and 123.456M These literals are converted to decimal values by using their exact representation and rounding to the nearest value when necessary, following banker's rounding rules The scale indicated in the literal is maintained unless the value is rounded or is zero, in which case both the sign and scale are set to zero For instance, the literal 2.900m is parsed to yield a decimal with a sign of 0, a coefficient of 2900, and a scale of 3.
If the specified literal cannot be represented in the indicated type, a compile-time error occurs.
The value of a real literal of type float or double is determined by using the IEEE “round to nearest” mode.
Note that in a real literal, decimal digits are always required after the decimal point For example, 1.3F is a real literal but 1.F is not.
A character literal represents a single character, and usually consists of a character in quotes, as in 'a'. character-literal:
' character ' character: single-character simple-escape-sequence hexadecimal-escape-sequence unicode-escape-sequence single-character:
Any character except ' (U+0027), \ (U+005C), and new-line-character simple-escape-sequence: one of
\x hex-digit hex-digit opt hex-digit opt hex-digit opt
A character that follows a backslash character (\) in a character must be one of the following characters: ', ", \,
0, a, b, f, n, r, t, u, U, x, v Otherwise, a compile-time error occurs.
A hexadecimal escape sequence represents a single Unicode character, with the value formed by the hexadecimal number following “\x”.
If the value represented by a character literal is greater than U+FFFF, a compile-time error occurs.
A Unicode character escape sequence (§2.4.1) in a character literal must be in the range U+0000 to U+FFFF
A simple escape sequence represents a Unicode character encoding, as described in the table below.
The type of a character-literal is char.
C# supports two forms of string literals: regular string literals and verbatim string literals
A regular string literal is defined as a sequence of characters enclosed in double quotes, such as "hello." It can incorporate simple escape sequences like \t for a tab, as well as hexadecimal and Unicode escape sequences.
A verbatim string literal begins with an @ symbol followed by a double quote, containing any number of characters before a closing double quote, such as @"hello" In this format, the characters within the delimiters are interpreted exactly as they appear, with the exception of quote-escape sequences Notably, simple escape sequences, as well as hexadecimal and Unicode escape sequences, are not processed in verbatim string literals, which can also extend across multiple lines.
Pre-processing directives
Pre-processing directives allow for the conditional exclusion of source file sections, reporting of errors and warnings, and the organization of distinct code regions While the term "pre-processing directives" aligns with C and C++ terminology, C# processes these directives during the lexical analysis phase without a separate pre-processing step Key types of directives include pp-declaration, pp-conditional, pp-line, pp-diagnostic, pp-region, and pp-pragma.
The following pre-processing directives are available:
• #define and #undef, which are used to define and undefine, respectively, conditional compilation symbols (§2.5.3).
• #if, #elif, #else, and #endif, which are used to conditionally skip sections of source code (§2.5.4).
• #line, which is used to control line numbers emitted for errors and warnings (§2.5.7).
• #error and #warning, which are used to issue errors and warnings, respectively (§2.5.5).
• #region and #endregion, which are used to explicitly mark sections of source code (§2.5.6).
• #pragma, which is used to specify optional contextual information to the compiler (§2.5.8).
A pre-processing directive is a specific instruction in source code that starts with a # character, followed by the directive name, and is always placed on a separate line Additionally, white space can appear before the # character and between the # character and the directive name.
Source lines that include directives such as #define, #undef, #if, #elif, #else, #endif, or #line can conclude with a single-line comment However, delimited comments using the /**/ format are not allowed on these source lines with pre-processing directives.
Pre-processing directives in C# are not considered tokens or part of the language's syntactic grammar However, they play a crucial role in including or excluding sequences of tokens, thereby influencing the overall meaning of a C# program.
} results in the exact same sequence of tokens as the program: class C
Thus, whereas lexically, the two programs are quite different, syntactically, they are identical.
The conditional compilation functionality provided by the #if, #elif, #else, and #endif directives is controlled through pre-processing expressions (§2.5.2) and conditional compilation symbols. conditional-symbol:
Any identifier-or-keyword except true or false
A conditional compilation symbol can either be defined or undefined Initially, a symbol is considered undefined until explicitly defined through an external mechanism, such as a command-line compiler option When a #define directive is encountered, the specified symbol becomes defined for that source file and remains defined until an #undef directive is processed or the end of the file is reached It's important to note that #define and #undef directives in one source file do not influence other source files within the same program.
In pre-processing expressions, a defined conditional compilation symbol evaluates to true, while an undefined symbol evaluates to false There is no need to explicitly declare conditional compilation symbols prior to their use in these expressions, as undeclared symbols are treated as undefined and automatically assigned a value of false.
In C#, conditional compilation symbols are uniquely designated and exist independently from other named entities within a program These symbols can exclusively be utilized in #define and #undef directives, as well as in pre-processing expressions.
Pre-processing expressions can be utilized within #if and #elif directives, allowing the use of operators such as !, ==, !=, &&, and || Parentheses can also be employed for grouping purposes The structure of a pre-processing expression includes optional whitespace and is organized into several components: the pp-or-expression, which combines pp-and-expressions with the || operator; the pp-and-expression, which links pp-equality-expressions using the && operator; and the pp-equality-expression, which consists of pp-unary-expressions connected by the == or != operators Lastly, pp-unary-expressions are derived from pp-primary-expressions.
! whitespace opt pp-unary-expression pp-primary-expression: true false conditional-symbol
( whitespace opt pp-expression whitespace opt )
When referenced in a pre-processing expression, a defined conditional compilation symbol has the boolean value true, and an undefined conditional compilation symbol has the boolean value false.
A pre-processing expression consistently evaluates to a boolean value, following the same evaluation rules as constant expressions However, it is important to note that only conditional compilation symbols can be referenced as user-defined entities within these expressions.
The declaration directives serve to define or undefine conditional compilation symbols, utilizing the syntax: `# define conditional-symbol` or `# undef conditional-symbol` These directives are structured with optional whitespace and may include single-line comments, ensuring clarity in the code.
The #define directive initiates the definition of a conditional compilation symbol from the subsequent source line, while the #undef directive begins the process of undefined status for that symbol from the following line.
In a source file, all #define and #undef directives must be placed before the first token to avoid compile-time errors This means that these directives should always come first in the file to ensure proper compilation.
“real code” in the source file.
The validity of the #define directives is ensured as they appear before the first token, specifically the namespace keyword, in the source file Conversely, a compile-time error occurs when a #define directive is placed after actual code.
A #define can redefine a conditional compilation symbol that is already established, even if there hasn't been an intervening #undef for that symbol For instance, the code snippet below illustrates the redefinition of the conditional compilation symbol A.
The #undef directive can be used to "undefine" a conditional compilation symbol, even if that symbol is not currently defined For instance, when a conditional compilation symbol A is defined and then subsequently undefines it twice, the second #undef is redundant but remains a valid operation.