C# Language Standard

The C# Language Specification is organized into several major sections that define how the language is structured, parsed, and executed. Key areas include:

• Lexical Structure (§6): Defines the basic building blocks of the language, including programs, grammars, lexical analysis, tokens (identifiers, keywords, literals), and pre-processing directives.
• Basic Concepts (§7): Covers fundamental execution models like application startup/termination, declarations, member access (accessibility domains), and scopes.
• Types (§8): Details the type system, including reference types (classes, interfaces, arrays), value types (structs, enums, tuples), constructed types (generics), and nullability (non-nullable and nullable reference types).
• Variables (§9): Explains variable categories (static, instance, local, parameters), default values, and the rules for Definite Assignment.

The C# Language Specification defines the formal structure and interpretation of C# programs. It is divided into what the specification covers and what it explicitly excludes.

What is covered:

• Program Representation: How C# programs are structured.
• Syntax and Constraints: The formal grammar and rules of the language.
• Semantic Rules: The logic and rules used to interpret C# programs.
• Implementation Limits: The restrictions and boundaries imposed on any conforming C# implementation.

What is NOT covered:

• Transformation Mechanisms: How programs are transformed for use by data-processing systems.
• Invocation Mechanisms: How C# applications are started or invoked.
• Data Transformation: How input data is prepared for an application or how output data is processed after production.
• System Capacity: The size or complexity limits of programs/data relative to specific hardware or processors.
• System Requirements: The minimal hardware or software requirements for a data-processing system to support a conforming C# implementation.

A constant expression is an expression that must be fully evaluated at compile-time. When an expression meets the requirements for a constant expression, it is evaluated during compilation, even if it is a subexpression of a larger expression containing non-constant constructs.

Key Characteristics:

• Compile-time evaluation: Uses the same rules as run-time evaluation, but instead of throwing exceptions, it triggers compile-time errors.
• Overflow behavior: Unless explicitly placed in an unchecked context, integral-type arithmetic overflows during compile-time evaluation cause compile-time errors.
• Permitted Types: A constant expression must result in null or one of the following types:
  • sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string
  • An enumeration type
  • A default value expression for a reference type

// Example of valid constant expressions
const int x = 5 + 5; // Evaluated at compile-time
const string s = "hello";
const MyEnum e = MyEnum.Value;

C# provides a model for extended indexable and sliceable collections using System.Index and System.Range. This model allows for more expressive ways to access elements and sub-sections of collections like arrays and strings.

Key Concepts

• Collection: A type representing a group of elements.
• Countable Collection: A collection that provides a Length or Count property (an int).
• Sequence / Indexable Type: A countable collection where elements can be accessed via an element_access expression using an int (from-start index).
• Extended Indexable: A type that supports element_access using a System.Index argument.
• Sliceable Collection: A collection that provides a Slice(int index, int count) method.
• Extended Sliceable: A type that supports element_access using a System.Range argument.

Requirements for Implementation

To implement this model in your own types, you can provide appropriate indexers. A type can inherit these capabilities; for example, a class providing Length is countable, a derived class providing an int indexer is a sequence, and a further derived class providing a Slice method is sliceable.

Pre-processing directives in C# allow you to conditionally skip sections of code, report errors/warnings, delineate code regions, and manage the nullable context. Unlike C or C++, these are processed during the lexical analysis phase rather than in a separate pre-processing step.

Key Rules:

• Directives always occupy a separate line.
• They always begin with a # character (whitespace is allowed before the # and between the # and the directive name).
• #define, #undef, #if, #elif, #else, #endif, #line, #endregion, and #nullable directives can end with a single-line comment (//).
• Delimited comments (/* */) are not permitted on the same line as a pre-processing directive.
• Directives are not part of the syntactic grammar, but they can affect the meaning of a program by including or excluding tokens.

#define A
#undef B
class C
{
#if A
    void F() {}
#else
    void G() {}
#endif
}

For the expression expr_first && expr_second:

• The state of v before expr_first is the same as before the expression.
• v is definitely assigned before expr_second if and only if the state after expr_first is either 'definitely assigned' or 'definitely assigned after true expression'.
• The state after the whole expression depends on the states after expr_first and expr_second. For example, if expr_first results in 'definitely assigned after false expression' and expr_second results in 'definitely assigned', the final state is 'definitely assigned'.

Example of conditional assignment:

class A
{
    static void F(int x, int y)
    {
        int i;
        if (x >= 0 && (i = y) >= 0)
        {
            // i is definitely assigned here because (i = y) always executes
        }
        else
        {
            // i is NOT definitely assigned here because x >= 0 might be false
        }
    }
}

class A
{
    static void F(int x, int y)
    {
        int i;
        if (x >= 0 && (i = y) >= 0)
        {
            // i definitely assigned
        }
        else
        {
            // i not definitely assigned
        }
        // i not definitely assigned
    }
}