• The program does not use a global method for Main. Methods and variables are not supported at the global level; such elements are always contained within type declarations (e.g., class and struct declarations).
• The program does not use either "::" or "->" operators. The "::" is not an operator at all, and the "->" operator is used in only a small fraction of programs (which involve unsafe code). The separator "." is used in compound names such as Console.WriteLine.
• The program does not contain forward declarations. Forward declarations are never needed, as declaration order is not significant.
• The program does not use #include to import program text. Dependencies among programs are handled symbolically rather than textually. This approach eliminates barriers between applications written using multiple languages. For example, the Console class need not be written in C#.

class Test  
{  
   static void Main() {  
      int[] a1 = new int[] {1, 2, 3};  
      int[,] a2 = new int[,] {{1, 2, 3}, {4, 5, 6}};  
      int[,,] a3 = new int[10, 20, 30];  
      int[][] j2 = new int[3][];  
      j2[0] = new int[] {1, 2, 3};  
      j2[1] = new int[] {1, 2, 3, 4, 5, 6};  
      j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};  
   }  
}  

int[,,] a3 = new int[10, 20, 30];  

int[] a1 = new int[] {1, 2, 3};  

int[] a1 = {1, 2, 3};  

class Test  
{  
   static void Main() {  
      short[] a = {1, 2, 3};  
      int[] b = {1, 2, 3};  
      long[] c = {1, 2, 3};  
   }  
}  

using Personnel.Data;  
class Employee  
{  
   private static DataSet ds;  
   public string Name;  
   public decimal Salary;  
   ...  
}  

using System;  
class Test {  
   static void F(int p) {  
      Console.WriteLine("p = {0}", p);  
      p++;  
   }  
   static void Main() {  
      int a = 1;  
      Console.WriteLine("pre:  a = {0}", a);  
      F(a);  
      Console.WriteLine("post: a = {0}", a);  
   }  
}  

pre:  a = 1  
p = 1  
post: a = 1  

using System;  
class Test {  
   static void Swap(ref int a, ref int b) {  
      int t = a;  
      a = b;  
      b = t;  
   }  
   static void Main() {  
      int x = 1;  
      int y = 2;  
      
      Console.WriteLine("pre:  x = {0}, y = {1}", x, y);  
      Swap(ref x, ref y);  
      Console.WriteLine("post: x = {0}, y = {1}", x, y);  
   }  
}  

pre:  x = 1, y = 2  
post: x = 2, y = 1  

using System;  
class Test {  
   static void Divide(int a, int b, out int result, out int remainder) {  
      result = a / b;  
      remainder = a % b;  
   }  
   static void Main() {  
      for (int i = 1; i < 10; i++)  
      for (int j = 1; j < 10; j++) {  
         int ans, r;  
         Divide(i, j, out ans, out r);  
         Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);  
      }  
   }  
}  

using System;  
class Test  
{  
   static void F(params int[] args) {  
      Console.WriteLine("# of arguments: {0}", args.Length);  
      for (int i = 0; i < args.Length; i++)  
      Console.WriteLine("\targs[{0}] = {1}", i, args[i]);  
   }  
   static void Main() {  
      F();  
      F(1);  
      F(1, 2);  
      F(1, 2, 3);  
      F(new int[] {1, 2, 3, 4});  
   }  
}  

# of arguments: 0  
# of arguments: 1  
args[0] = 1  
# of arguments: 2  
args[0] = 1  
args[1] = 2  
# of arguments: 3  
args[0] = 1  
args[1] = 2  
args[2] = 3  
# of arguments: 4  
args[0] = 1  
args[1] = 2  
args[2] = 3  
args[3] = 4  

int a = 1, b = 2;  
Console.WriteLine("a = {0}, b = {1}", a, b);  

namespace System  
{  
   public class Console  
   {  
      public static void WriteLine(string s) {...}  
      public static void WriteLine(string s, object a) {...}  
      public static void WriteLine(string s, object a, object b) {...}  
      ...  
      public static void WriteLine(string s, params object[] args) {...}  
   }  
}  

using System;  
class MyClass  
{  
   public MyClass() {  
      Console.WriteLine("Instance constructor");  
   }  
   public MyClass(int value) {  
      MyField = value;  
      Console.WriteLine("Instance constructor");  
   }  
   ~MyClass() {  
      Console.WriteLine("Destructor");  
   }  
   public const int MyConst = 12;  
   public int MyField = 34;  
   public void MyMethod(){  
      Console.WriteLine("MyClass.MyMethod");  
   }  
   public int MyProperty {  
      get {  
         return MyField;  
      }  
      set {  
         MyField = value;  
      }  
   }  
   public int this[int index] {  
      get {  
         return 0;  
      }  
      set {  
         Console.WriteLine("this[{0}] = {1}", index, value);  
      }  
   }  
   public event EventHandler MyEvent;  
   public static MyClass operator+(MyClass a, MyClass b) {  
      return new MyClass(a.MyField + b.MyField);  
   }  
   internal class MyNestedClass  
   {}  
}  

class Test  
{  
   static void Main() {  
      // Instance constructor usage  
      MyClass a = new MyClass();  
      MyClass b = new MyClass(123);  
      // Constant usage  
      Console.WriteLine("MyConst = {0}", MyClass.MyConst);  
      // Field usage  
      a.MyField++;  
      Console.WriteLine("a.MyField = {0}", a.MyField);  
      // Method usage  
      a.MyMethod();  
      // Property usage  
      a.MyProperty++;  
      Console.WriteLine("a.MyProperty = {0}", a.MyProperty);  
      // Indexer usage  
      a[3] = a[1] = a[2];  
      Console.WriteLine("a[3] = {0}", a[3]);  
      // Event usage  
      a.MyEvent += new EventHandler(MyHandler);  
      // Overloaded operator usage  
      MyClass c = a + b;  
   }  
   static void MyHandler(object sender, EventArgs e) {  
      Console.WriteLine("Test.MyHandler");  
   }  
   internal class MyNestedClass  
   {}  
}  

using System;  
class Test  
{  
   static void Main() {  
      Console.WriteLine("{0}, {1}", Constants.A, Constants.B);  
   }  
}  

using System;  
class Test  
{  
   static void F() {  
      Console.WriteLine("F()");  
   }  
   static void F(object o) {  
      Console.WriteLine("F(object)");  
   }  
   static void F(int value) {  
      Console.WriteLine("F(int)");  
   }  
   static void F(ref int value) {  
      Console.WriteLine("F(ref int)");  
   }  
   static void F(int a, int b) {  
      Console.WriteLine("F(int, int)");  
   }  
   static void F(int[] values) {  
      Console.WriteLine("F(int[])");  
   }  
   static void Main() {  
      F();  
      F(1);  
      int i = 10;  
      F(ref i);  
      F((object)1);  
      F(1, 2);  
      F(new int[] {1, 2, 3});  
   }  
}  

F()  
F(int)  
F(ref int)  
F(object)  
F(int, int)  
F(int[])  

delegate void SimpleDelegate();  

class Test  
{  
   static void F() {  
      System.Console.WriteLine("Test.F");  
   }  
   static void Main() {  
      SimpleDelegate d = new SimpleDelegate(F);  
      d();  
   }  
}  

void MultiCall(SimpleDelegate d, int count) {  
   for (int i = 0; i < count; i++) {  
      d();  
   }  
}  

using System;  
[AttributeUsage(AttributeTargets.All)]  
public class HelpAttribute: Attribute  
{  
   public HelpAttribute(string url) {  
      this.url = url;  
   }  
   public string Topic = null;  
   private string url;  
   public string Url {   
      get { return url; }  
   }  
}  

[Help("http://www.mycompany.com/.../Class1.htm")]  
public class Class1   
{  
   [Help("http://www.mycompany.com/.../Class1.htm", Topic = "F")]  
   public void F() {}  
}  

using System;  
class Test  
{  
   static void Main() {  
      Type type = typeof(Class1);  
      object[] arr = type.GetCustomAttributes(typeof(HelpAttribute),  
      true);  
      if (arr.Length == 0)  
      Console.WriteLine("Class1 has no Help attribute.");  
      else {  
         HelpAttribute ha = (HelpAttribute) arr[0];  
         Console.WriteLine("Url = {0}, Topic = {1}", ha.Url, ha.Topic);  
      }  
   }  
}  

• 2 If the last character of the source file is a Control-Z character (U+001A), this character is deleted.
• 3 A carriage-return character (U+000D) is added to the end of the source file if that source file is non-empty and if the last character of the source file is not a carriage return (U+000D), a line feed (U+000A), a line separator (U+2028), or a paragraph separator (U+2029).

• 2 The prefix "@", if used, is removed.
• 3 Each unicode-escape-sequence is transformed into its corresponding Unicode character.
• 4 Any formatting-characters are removed.

• 2 If the literal has no suffix, it has the first of these types in which its value can be represented: int, uint, long, ulong.
• 3 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.
• 4 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.
• 5 If the literal is suffixed by UL, Ul, uL, ul, LU, Lu, lU, or lu, it is of type ulong.

• 2 When a decimal-integer-literal with the value 2147483648 (2³¹) and no integer-type-suffix appears as the token immediately following a unary minus operator token (§14.6.2), the result is a constant of type int with the value −2147483648 (−2³¹). 3 In all other situations, such a decimal-integer-literal is of type uint.
• 4 When a decimal-integer-literal with the value 9223372036854775808 (2⁶³) and no integer-type-suffix or the integer-type-suffix L or l appears as the token immediately following a unary minus operator token (§14.6.2), the result is a constant of type long with the value −9223372036854775808 (−2⁶³). 5 In all other situations, such a decimal-integer-literal is of type ulong.

• 3 A real literal suffixed by F or f is of type float. [Example: For example, the literals 1f, 1.5f, 1e10f, and 123.456F are all of type float. end example]
• 4 A real literal suffixed by D or d is of type double. [Example: For example, the literals 1d, 1.5d, 1e10d, and 123.456D are all of type double. end example]
• 5 A real literal suffixed by M or m is of type decimal. [Example: For example, the literals 1m, 1.5m, 1e10m, and 123.456M are all of type decimal. end example] 6 This literal is converted to a decimal value by taking the exact value, and, if necessary, rounding to the nearest representable value using banker's rounding (§11.1.6). 7 Any scale apparent in the literal is preserved unless the value is rounded or the value is zero (in which latter case the sign and scale will be 0). [Note: Hence, the literal 2.900m will be parsed to form the decimal with sign 0, coefficient 2900, and scale 3. end note]

• 2 #define and #undef, which are used to define and undefine, respectively, conditional compilation symbols (§9.5.3).
• 3 #if, #elif, #else, and #endif, which are used to conditionally skip sections of source code (§9.5.1).
• 4 #line, which is used to control line numbers emitted for errors and warnings (§9.5.7).
• 5 #error and #warning, which are used to issue errors and warnings, respectively (§9.5.5).
• 6 #region and #endregion, which are used to explicitly mark sections of source code (§9.5.6).

• 2 The pp-expressions of the #if and #elif directives are evaluated in order until one yields true. 3 If an expression yields true, the conditional-section of the corresponding directive is selected.
• 4 If all pp-expressions yield false, and if an #else directive is present, the conditional-section of the #else directive is selected.
• 5 Otherwise, no conditional-section is selected.

• 3 The implementation shall ensure that the value of this parameter is not null.
• 4 Let args be the name of the parameter. 5 If the length of the array designated by args is greater than zero, the array members args[0] through args[args.Length-1], inclusive, must refer to strings, called application parameters, which are given implementation-defined values by the host environment prior to application startup. 6 The intent is to supply to the application information determined prior to application startup from elsewhere in the hosted environment. 7 If the host environment is not capable of supplying strings with letters in both uppercase and lowercase, the implementation shall ensure that the strings are received in lowercase. [Note: On systems supporting a command line, application parameters correspond to what are generally known as command-line arguments. end note]

• 2 Within all source files of a program, namespace-member-declarations with no enclosing namespace-declaration are members of a single combined declaration space called the global declaration space.
• 3 Within all source files of a program, namespace-member-declarations within namespace-declarations that have the same fully qualified namespace name are members of a single combined declaration space.
• 4 Each class, struct, or interface declaration creates a new declaration space. 5 Names are introduced into this declaration space through class-member-declarations, struct-member-declarations, or interface-member-declarations. 6 Except for overloaded instance constructor declarations and static constructor declarations, a class or struct member declaration cannot introduce a member by the same name as the class or struct. 7 A class, struct, or interface permits the declaration of overloaded methods and indexers. 8 Furthermore, a class or struct permits the declaration of overloaded instance constructors and operators. [Example: For example, a class, struct, or interface may contain multiple method declarations with the same name, provided these method declarations differ in their signature (§10.6). end example] 9 Note that base classes do not contribute to the declaration space of a class, and base interfaces do not contribute to the declaration space of an interface. 10 Thus, a derived class or interface is allowed to declare a member with the same name as an inherited member. 11 Such a member is said to hide the inherited member.
• 12 Each enumeration declaration creates a new declaration space. 13 Names are introduced into this declaration space through enum-member-declarations.
• 14 Each block or switch-block creates a different declaration space for local variables. 15 Names are introduced into this declaration space through local-variable-declarations. 16 If a block is the body of an instance constructor, method, or operator declaration, or a get or set accessor for an indexer declaration, the parameters declared in such a declaration are members of the block's local variable declaration space. 17 The local variable declaration space of a block includes any nested blocks. 18 Thus, within a nested block it is not possible to declare a local variable with the same name as a local variable in an enclosing block.
• 19 Each block or switch-block creates a separate declaration space for labels. 20 Names are introduced into this declaration space through labeled-statements, and the names are referenced through goto-statements. 21 The label declaration space of a block includes any nested blocks. 22 Thus, within a nested block it is not possible to declare a label with the same name as a label in an enclosing block.

• 4 Declaration order for field declarations and local variable declarations determines the order in which their initializers (if any) are executed.
• 5 Local variables must be defined before they are used (§10.7).
• 6 Declaration order for enum member declarations (§21.3) is significant when constant-expression values are omitted.

• 2 The members of sbyte are the members of the System.SByte struct.
• 3 The members of byte are the members of the System.Byte struct.
• 4 The members of short are the members of the System.Int16 struct.
• 5 The members of ushort are the members of the System.UInt16 struct.
• 6 The members of int are the members of the System.Int32 struct.
• 7 The members of uint are the members of the System.UInt32 struct.
• 8 The members of long are the members of the System.Int64 struct.
• 9 The members of ulong are the members of the System.UInt64 struct.
• 10 The members of char are the members of the System.Char struct.
• 11 The members of float are the members of the System.Single struct.
• 12 The members of double are the members of the System.Double struct.
• 13 The members of decimal are the members of the System.Decimal struct.
• 14 The members of bool are the members of the System.Boolean struct.

• 2 The members of object are the members of the System.Object class.
• 3 The members of string are the members of the System.String class.

• 3 Namespaces implicitly have public declared accessibility. 4 No access modifiers are allowed on namespace declarations.
• 5 Types declared in compilation units or namespaces can have public or internal declared accessibility and default to internal declared accessibility.
• 6 Class members can have any of the five kinds of declared accessibility and default to private declared accessibility. [Note: A type declared as a member of a class can have any of the five kinds of declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility. end note])
• 7 Struct members can have public, internal, or private declared accessibility and default to private declared accessibility because structs are implicitly sealed. 8 Struct members introduced in a struct (that is, not inherited by that struct) cannot have protected or protected internal declared accessibility. [Note: A type declared as a member of a struct can have public, internal, or private declared accessibility, whereas a type declared as a member of a namespace can have only public or internal declared accessibility. end note])
• 9 Interface members implicitly have public declared accessibility. 10 No access modifiers are allowed on interface member declarations.
• 11 Enumeration members implicitly have public declared accessibility. 12 No access modifiers are allowed on enumeration member declarations.

• 2 If the declared accessibility of T is public, the accessibility domain of T is the program text of P and any program that references P.
• 3 If the declared accessibility of T is internal, the accessibility domain of T is the program text of P.

• 2 If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.
• 3 If the declared accessibility of M is protected internal, let D be the union of the program text of P and the program text of any type derived from T, which is declared outside P. 4 The accessibility domain of M is the intersection of the accessibility domain of T with D.
• 5 If the declared accessibility of M is protected, let D be the union of the program text of T and the program text of any type derived from T. 6 The accessibility domain of M is the intersection of the accessibility domain of T with D.
• 7 If the declared accessibility of M is internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P.
• 8 If the declared accessibility of M is private, the accessibility domain of M is the program text of T.

• 2 The direct base class of a class type must be at least as accessible as the class type itself.
• 3 The explicit base interfaces of an interface type must be at least as accessible as the interface type itself.
• 4 The return type and parameter types of a delegate type must be at least as accessible as the delegate type itself.
• 5 The type of a constant must be at least as accessible as the constant itself.
• 6 The type of a field must be at least as accessible as the field itself.
• 7 The return type and parameter types of a method must be at least as accessible as the method itself.
• 8 The type of a property must be at least as accessible as the property itself.
• 9 The type of an event must be at least as accessible as the event itself.
• 10 The type and parameter types of an indexer must be at least as accessible as the indexer itself.
• 11 The return type and parameter types of an operator must be at least as accessible as the operator itself.
• 12 The parameter types of an instance constructor must be at least as accessible as the instance constructor itself.

• 2 Overloading of methods permits a class, struct, or interface to declare multiple methods with the same name, provided their signatures are unique within that class, struct, or interface.
• 3 Overloading of instance constructors permits a class or struct to declare multiple instance constructors, provided their signatures are unique within that class or struct.
• 4 Overloading of indexers permits a class, struct, or interface to declare multiple indexers, provided their signatures are unique within that class, struct, or interface.
• 5 Overloading of operators permits a class or struct to declare multiple operators with the same name, provided their signatures are unique within that class or struct.

• 2 If the namespace-or-type-name consists of a single identifier:
• 3 If the namespace-or-type-name appears within the body of a class or struct declaration, then starting with that class or struct declaration and continuing with each enclosing class or struct declaration (if any), if a member with the given name exists, is accessible, and denotes a type, then the namespace-or-type-name refers to that member. 4 Non-type members (constants, fields, methods, properties, indexers, operators, instance constructors, destructors, and static constructors) are ignored when determining the meaning of a namespace-or-type-name.
• 5 Otherwise, starting with the namespace in which the namespace-or-type-name occurs, continuing with each enclosing namespace (if any), and ending with the global namespace, the following steps are evaluated until an entity is located:
• 6 If the namespace contains a namespace member with the given name, then the namespace-or-type-name refers to that member and, depending on the member, is classified as a namespace or a type.
• 7 Otherwise, if the namespace has a corresponding namespace declaration enclosing the location where the namespace-or-type-name occurs, then:
• 8 If the namespace declaration contains a using-alias-directive that associates the given name with an imported namespace or type, then the namespace-or-type-name refers to that namespace or type.
• 9 Otherwise, if the namespaces imported by the using-namespace-directives of the namespace declaration contain exactly one type with the given name, then the namespace-or-type-name refers to that type.
• 10 Otherwise, if the namespaces imported by the using-namespace-directives of the namespace declaration contain more than one type with the given name, then the namespace-or-type-name is ambiguous and an error occurs.
• 11 Otherwise, the namespace-or-type-name is undefined and a compile-time error occurs.
• 12 Otherwise, the namespace-or-type-name is of the form N.I, where N is a namespace-or-type-name consisting of all identifiers but the rightmost one, and I is the rightmost identifier. 13 N is first resolved as a namespace-or-type-name. 14 If the resolution of N is not successful, a compile-time error occurs. 15 Otherwise, N.I is resolved as follows:
• 16 If N is a namespace and I is the name of an accessible member of that namespace, then N.I refers to that member and, depending on the member, is classified as a namespace or a type.
• 17 If N is a class or struct type and I is the name of an accessible type in N, then N.I refers to that type.
• 18 Otherwise, N.I is an invalid namespace-or-type-name, and a compile-time error occurs.

• 2 For all simple-types, the default value is the value produced by a bit pattern of all zeros:
• 3 For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.
• 4 For char, the default value is '\x0000'.
• 5 For float, the default value is 0.0f.
• 6 For double, the default value is 0.0d.
• 7 For decimal, the default value is 0.0m.
• 8 For bool, the default value is false.
• 9 For an enum-type E, the default value is 0.
• 10 For a struct-type, the default value is the value produced by setting all value type fields to their default value and all reference type fields to null.

class A  
{  
   void F() {  
      int i = 0;  
      int j = new int();  
   }  
}  

int i = int.MaxValue;      // System.Int32.MaxValue constant  
string s = i.ToString();    // System.Int32.ToString() instance method  
string t = 123.ToString();   // System.Int32.ToString() instance method  

• 3 Most simple types permit values to be created by writing literals (§9.4.4). [Example: For example, 123 is a literal of type int and 'a' is a literal of type char. end example] 4 C# makes no provision for literals of struct types in general, and non-default values of other struct types are ultimately always created through instance constructors of those struct types.
• 5 When the operands of an expression are all simple type constants, the compiler evaluates the expression at compile-time. 6 Such an expression is known as a constant-expression (§14.15). 7 Expressions involving operators defined by other struct types are not considered to be constant expressions.
• 8 Through const declarations, it is possible to declare constants of the simple types (§17.3). 9 It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.
• 10 Conversions involving simple types can participate in evaluation of conversion operators defined by other struct types, but a user-defined conversion operator can never participate in evaluation of another user-defined operator (§13.4.2).

• 2 For the unary + and ~ operators, the operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. 3 The operation is then performed using the precision of type T, and the type of the result is T.
• 4 For the unary -operator, the operand is converted to type T, where T is the first of int and long that can fully represent all possible values of the operand. 5 The operation is then performed using the precision of type T, and the type of the result is T. 6 The unary -operator cannot be applied to operands of type ulong.
• 7 For the binary +, -, *, /, %, &, ^, |, ==, !=, >, <, >=, and <= operators, the operands are converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of both operands. 8 The operation is then performed using the precision of type T, and the type of the result is T (or bool for the relational operators). 9 It is not permitted for one operand to be of type long and the other to be of type ulong with the binary operators.
• 10 For the binary << and >> operators, the left operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. 11 The operation is then performed using the precision of type T, and the type of the result is T.

• 2 There are no implicit conversions from other types to the char type. 3 In particular, even though the sbyte, byte, and ushort types have ranges of values that are fully representable using the char type, implicit conversions from sbyte, byte, or ushort to char do not exist.
• 4 Constants of the char type must be written as character-literals or as integer-literals in combination with a cast to type char. [Example: For example, (char)10 is the same as '\x000A'. end example]

• 2 If one of the operands is of an integral type, then that operand is converted to the floating-point type of the other operand.
• 3 Then, if either of the operands is of type double, the other operand is converted to double, the operation is performed using at least double range and precision, and the type of the result is double (or bool for the relational operators).
• 4 Otherwise, the operation is performed using at least float range and precision, and the type of the result is float (or bool for the relational operators).

• 3 If the result of a floating-point operation is too small for the destination format, the result of the operation becomes positive zero or negative zero.
• 4 If the result of a floating-point operation is too large for the destination format, the result of the operation becomes positive infinity or negative infinity.
• 5 If a floating-point operation is invalid, the result of the operation becomes NaN.
• 6 If one or both operands of a floating-point operation is NaN, the result of the operation becomes NaN.