This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.

Basics

Identifier

An identifier is the name of an element in the code. It can contain letters, digits and underscores, and is case sensitive ( is different from ). The language imposes the following restrictions on identifier names: Identifier names may be prefixed by an at sign, but this is insignificant; is the same identifier as. Microsoft has published naming conventions for identifiers in C#, which recommends the use of PascalCase for the names of types and most type members, and camelCase for variables and for private or internal fields. However, these naming conventions are not enforced in the language.

Keywords

Keywords are predefined reserved words with special syntactic meaning. The language has two types of keyword — contextual and reserved. The reserved keywords such as or may only be used as keywords. The contextual keywords such as or are only treated as keywords in certain situations. If an identifier is needed which would be the same as a reserved keyword, it may be prefixed by an at sign to distinguish it. For example, is interpreted as an identifier, whereas as a keyword. This syntax facilitates reuse of .NET code written in other languages. The following C# keywords are reserved words: A contextual keyword is used to provide a specific meaning in the code, but it is not a reserved word in C#. Some contextual keywords, such as and , have special meanings in multiple contexts. The following C# keywords are contextual:

Literals

Digit separators

Starting in C# 7.0, the underscore symbol can be used to separate digits in number values for readability purposes. The compiler ignores these underscores. Generally, it may be put only between digit characters. It cannot be put at the beginning (121) or the end of the value (121 or 121.05_), next to the decimal in floating point values (10_.0), next to the exponent character (1.1e_1), or next to the type specifier (10_f).

Variables

Variables are identifiers associated with values. They are declared by writing the variable's type and name, and are optionally initialized in the same statement. Declare Assigning Initialize Multiple variables of the same type can be declared and initialized in one statement.

Local variable type inference

C# 3.0 introduced type inference, allowing the type specifier of a variable declaration to be replaced by the keyword, if its actual type can be statically determined from the initializer. This reduces repetition, especially for types with multiple generic type-parameters, and adheres more closely to the DRY principle.

Constants

Constants are immutable values.

When declaring a local variable or a field with the keyword as a prefix the value must be given when it is declared. After that it is locked and cannot change. They can either be declared in the context as a field or a local variable. Constants are implicitly static. This shows both uses of the keyword.

The keyword does a similar thing to fields. Like fields marked as they cannot change once initialized. The difference is that one can choose to initialize them in a constructor, or to a value that is not known until run-time. This only works on fields. fields can either be members of an instance or static class members.

Code blocks

Curly braces are used to signify a code block and a new scope. Class members and the body of a method are examples of what can live inside these braces in various contexts. Inside of method bodies, braces can be used to create new scopes:

Program structure

A C# application consists of classes and their members. Classes and other types exist in namespaces but can also be nested inside other classes.

Main method

Whether it is a console or a graphical interface application, the program must have an entry point of some sort. The entry point of a C# application is the method. There can only be one declaration of this method, and it is a static method in a class. It usually returns and is passed command-line arguments as an array of strings. The main method is also allowed to return an integer value if specified.

Async Main

This is a feature of C# 7.1. Asynchronous Tasks can be awaited in the method by declaring the method's return type as. All the combinations of, or and with, or without, the parameter are supported.

Top-level statements

This is a feature of C# 9.0. Similar to in scripting languages, top-level statements removes the ceremony of having to declare the class with a method. Instead, statements can be written directly in one specific file, and that file will be the entry point of the program. Code in other files will still have to be defined in classes. This was introduced to make C# less verbose, and thus more accessible for beginners to get started. Types are declared after the statements, and will be automatically available from the statements above them.

Namespaces

Namespaces are a part of a type name and they are used to group and/or distinguish named entities from other ones. A namespace is defined like this: A namespace can be put inside a namespace like this: It can also be done like this: In C# 10 and later, namespaces can also be defined using file-scoped declarations by doing the following:

directive

The directive loads a specific namespace from a referenced assembly. It is usually placed in the top (or header) of a code file but it can be placed elsewhere if wanted, e.g. inside classes. The directive can also be used to define another name for an existing namespace or type. This is sometimes useful when names are too long and less readable.

directive

The directive loads the static members of a specified type into the current scope, making them accessible directly by the name of the member.

Operators

Operator overloading

Some of the existing operators can be overloaded by writing an overload method. These are the overloadable operators:

Conversion operators

The cast operator is not overloadable, but one can write a conversion operator method which lives in the target class. Conversion methods can define two varieties of operators, implicit and explicit conversion operators. The implicit operator will cast without specifying with the cast operator and the explicit operator requires it to be used. Implicit conversion operator Explicit conversion operator

operator

The operator will attempt to do a silent cast to a given type. It will return the object as the new type if possible, and otherwise will return null.

Null coalesce operator

The following: is shorthand for: Meaning that if the content of variable is not null, that content will be returned, otherwise the content of variable is returned. C# 8.0 introduces null-coalescing assignment, such that is equivalent to

Control structures

C# inherits most of the control structures of C/C++ and also adds new ones like the statement.

Conditional structures

These structures control the flow of the program through given conditions.

statement

The statement is entered when the given condition is true. Single-line case statements do not require block braces although it is mostly preferred by convention. Simple one-line statement: Multi-line with else-block (without any braces): Recommended coding conventions for an if-statement.

statement

The construct serves as a filter for different values. Each value leads to a "case". It is not allowed to fall through case sections and therefore the keyword is typically used to end a case. An unconditional in a case section can also be used to end a case. See also how statement can be used to fall through from one case to the next. Many cases may lead to the same code though. The default case handles all the other cases not handled by the construct.

Iteration structures

Iteration statements are statements that are repeatedly executed when a given condition is evaluated as true.

loop

loop

loop

The loop consists of three parts: declaration, condition and counter expression. Any of them can be left out as they are optional. Is equivalent to this code represented with a statement, except here the variable is not local to the loop.

loop

The statement is derived from the statement and makes use of a certain pattern described in C#'s language specification in order to obtain and use an enumerator of elements to iterate over. Each item in the given collection will be returned and reachable in the context of the code block. When the block has been executed the next item will be returned until there are no items remaining.

Jump statements

Jump statements are inherited from C/C++ and ultimately assembly languages through it. They simply represent the jump-instructions of an assembly language that controls the flow of a program.

Labels and statement

Labels are given points in code that can be jumped to by using the statement. Note that the label need not be positioned after the statement; it may be before it in the source file. The statement can be used in statements to jump from one case to another or to fall through from one case to the next.

statement

The statement breaks out of the closest loop or statement. Execution continues in the statement after the terminated statement, if any.

statement

The statement discontinues the current iteration of the current control statement and begins the next iteration. The loop in the code above reads characters by calling, skipping the statements in the body of the loop if the characters are spaces.

Exception handling

Runtime exception handling method in C# is inherited from Java and C++. The base class library has a class called from which all other exception classes are derived. An -object contains all the information about a specific exception and also the inner exceptions that were caused. Programmers may define their own exceptions by deriving from the class. An exception can be thrown this way:

statements

Exceptions are managed within blocks. The statements within the block are executed, and if any of them throws an exception, execution of the block is discontinued and the exception is handled by the block. There may be multiple blocks, in which case the first block with an exception variable whose type matches the type of the thrown exception is executed. If no block matches the type of the thrown exception, the execution of the outer block (or method) containing the statement is discontinued, and the exception is passed up and outside the containing block or method. The exception is propagated upwards through the call stack until a matching block is found within one of the currently active methods. If the exception propagates all the way up to the top-most method without a matching block being found, the entire program is terminated and a textual description of the exception is written to the standard output stream. The statements within the block are always executed after the and blocks, whether or not an exception was thrown. Such blocks are useful for providing clean-up code. Either a block, a block, or both, must follow the block.

Types

C# is a statically typed language like C and C++. That means that every variable and constant gets a fixed type when it is being declared. There are two kinds of types: value types and reference types.

Value types

Instances of value types reside on the stack, i.e. they are bound to their variables. If one declares a variable for a value type the memory gets allocated directly. If the variable gets out of scope the object is destroyed with it.

Structures

Structures are more commonly known as structs. Structs are user-defined value types that are declared using the keyword. They are very similar to classes but are more suitable for lightweight types. Some important syntactical differences between a class and a struct are presented later in this article. The primitive data types are all structs.

Pre-defined types

These are the primitive datatypes. Note: is not a struct and is not a primitive type.

Enumerations

Enumerated types (declared with ) are named values representing integer values. Enum variables are initialized by default to zero. They can be assigned or initialized to the named values defined by the enumeration type. Enum type variables are integer values. Addition and subtraction between variables of the same type is allowed without any specific cast but multiplication and division is somewhat more risky and requires an explicit cast. Casts are also required for converting enum variables to and from integer types. However, the cast will not throw an exception if the value is not specified by the type definition. Values can be combined using the bitwise-OR operator.

Reference types

Variables created for reference types are typed managed references. When the constructor is called, an object is created on the heap and a reference is assigned to the variable. When a variable of an object goes out of scope the reference is broken and when there are no references left the object gets marked as garbage. The garbage collector will then soon collect and destroy it. A reference variable is null when it does not reference any object.

Arrays

An array type is a reference type that refers to a space containing one or more elements of a certain type. All array types derive from a common base class,. Each element is referenced by its index just like in C++ and Java. An array in C# is what would be called a dynamic array in C++.

Initializers

Array initializers provide convenient syntax for initialization of arrays.

Multi-dimensional arrays

Arrays can have more than one dimension, for example 2 dimensions to represent a grid. See also

Classes

Classes are self-describing user-defined reference types. Essentially all types in the .NET Framework are classes, including structs and enums, that are compiler generated classes. Class members are by default, but can be declared as to be visible outside of the class or to be visible by any descendants of the class.

Strings

The class, or simply, represents an immutable sequence of unicode characters. Actions performed on a string will always return a new string. The class can be used when a mutable "string" is wanted.

Interface

Interfaces are data structures that contain member definitions with no actual implementation. A variable of an interface type is a reference to an instance of a class which implements this interface. See.

Delegates

C# provides type-safe object-oriented function pointers in the form of delegates. Initializing the delegate with an anonymous method. Initializing the delegate with lambda expression.

Events

Events are pointers that can point to multiple methods. More exactly they bind method pointers to one identifier. This can therefore be seen as an extension to delegates. They are typically used as triggers in UI development. The form used in C# and the rest of the Common Language Infrastructure is based on that in the classic Visual Basic. An event requires an accompanied event handler that is made from a special delegate that in a platform specific library like in Windows Presentation Foundation and Windows Forms usually takes two parameters: sender and the event arguments. The type of the event argument-object derive from the EventArgs class that is a part of the CLI base library. Once declared in its class the only way of invoking the event is from inside of the owner. A listener method may be implemented outside to be triggered when the event is fired. Custom event implementation is also possible: See also

Nullable types

Nullable types were introduced in C# 2.0 firstly to enable value types to be null (useful when working with a database). In reality this is the same as using the struct.

Pointers

C# has and allows pointers to selected types (some primitives, enums, strings, pointers, and even arrays and structs if they contain only types that can be pointed ) in unsafe context: methods and codeblock marked. These are syntactically the same as pointers in C and C++. However, runtime-checking is disabled inside blocks. Structs are required only to be pure structs with no members of a managed reference type, e.g. a string or any other class. In use:

Dynamic

Type is a feature that enables dynamic runtime lookup to C# in a static manner. Dynamic denotes a variable with an object with a type that is resolved at runtime, as opposed to compile-time, as normally is done. This feature takes advantage of the Dynamic Language Runtime (DLR) and has been designed specifically with the goal of interoperation with dynamically typed languages like IronPython and IronRuby (Implementations of Python and Ruby for .NET). Dynamic-support also eases interoperation with COM objects.

Anonymous types

Anonymous types are nameless classes that are generated by the compiler. They are only consumable and yet very useful in a scenario like where one has a LINQ query which returns an object on and one just wants to return some specific values. Then, define an anonymous type containing auto-generated read-only fields for the values. When instantiating another anonymous type declaration with the same signature the type is automatically inferred by the compiler.

Boxing and unboxing

Boxing is the operation of converting a value of a value type into a value of a corresponding reference type. Boxing in C# is implicit. Unboxing is the operation of converting a value of a reference type (previously boxed) into a value of a value type. Unboxing in C# requires an explicit type cast. Example:

Object-oriented programming (OOP)

C# has direct support for object-oriented programming.

Objects

An object is created with the type as a template and is called an instance of that particular type. In C#, objects are either references or values. No further syntactical distinction is made between those in code.

Object class

All types, even value types in their boxed form, implicitly inherit from the class, the ultimate base class of all objects. This class contains the most common methods shared by all objects. Some of these are and can be overridden. Classes inherit either directly or indirectly through another base class. Members Some of the members of the Object class:

Classes

Classes are fundamentals of an object-oriented language such as C#. They serve as a template for objects. They contain members that store and manipulate data in a real-life like way.

Differences between classes and structs

Although classes and structures are similar in both the way they are declared and how they are used, there are some significant differences. Classes are reference types and structs are value types. A structure is allocated on the stack when it is declared and the variable is bound to its address. It directly contains the value. Classes are different because the memory is allocated as objects on the heap. Variables are rather managed pointers on the stack which point to the objects. They are references. Structures differ from classes in several other ways. For example, while both offer an implicit default constructor which takes no arguments, one cannot redefine it for structs. Explicitly defining a differently-parametrized constructor will suppress the implicit default constructor in classes, but not in structs. All fields of a struct must be initialized in those kinds of constructors. Structs do not have finalizers and cannot inherit from another class like classes do. Implicitly, they are sealed and inherit from (which inherits from ). Structs are more suitable for smaller amounts of data. This is a short summary of the differences:

Declaration

A class is declared like this:

Partial class

A partial class is a class declaration whose code is divided into separate files. The different parts of a partial class must be marked with keyword. The usual reason for using partial classes is to split some class into a programmer-maintained and a tool-maintained part, i.e. some code is automatically generated by a user-interface designing tool or something alike.

Initialization

Before one can use the members of the class, initialize the variable with a reference to an object. To create it, call the appropriate constructor using the keyword. It has the same name as the class. For structs it is optional to explicitly call a constructor because the default one is called automatically. It is just needed to declare it and it gets initialized with standard values.

Object initializers

Provides a more convenient way of initializing public fields and properties of an object. Constructor calls are optional when there is a default constructor.

Collection initializers

Collection initializers give an array-like syntax for initializing collections. The compiler will simply generate calls to the Add-method. This works for classes that implement the interface.

Accessing members

Members of an instance and static members of a class are accessed using the operator. Accessing an instance member Instance members can be accessed through the name of a variable. Accessing a static class member Static members are accessed by using the name of the class or other type. Accessing a member through a pointer In unsafe code, members of a value (struct type) referenced by a pointer are accessed with the operator just like in C and C++.

Modifiers

Modifiers are keywords used to modify declarations of types and type members. Most notably there is a sub-group containing the access modifiers.

Class modifiers

Class member modifiers

modifier

The modifier states that a member belongs to the class and not to a specific object. Classes marked static are only allowed to contain static members. Static members are sometimes referred to as class members since they apply to the class as a whole and not to its instances.

Access modifiers

The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members. Something marked can be reached from anywhere. members can only be accessed from inside of the class they are declared in and will be hidden when inherited. Members with the modifier will be, but accessible when inherited. classes and members will only be accessible from the inside of the declaring assembly. Classes and structs are implicitly and members are implicitly if they do not have an access modifier. This table defines where the access modifiers can be used.

Constructors

A constructor is a special method that is called automatically when an object is created. Its purpose is to initialize the members of the object. Constructors have the same name as the class and do not return anything explicitly. Implicitly, they will return the newly created object when called via the operator. They may take parameters like any other method. The parameter-less constructor is special because it can be specified as a necessary constraint for a generic type parameter. Constructors can be, , or.

Destructor

The destructor is called when the object is being collected by the garbage collector to perform some manual clean-up. There is a default destructor method called that can be overridden by declaring one. The syntax is similar to the one of constructors. The difference is that the name is preceded by a ~ and it cannot contain any parameters. There cannot be more than one destructor. Finalizers are always.

Methods

Like in C and C++ there are functions that group reusable code. The main difference is that functions, just like in Java, have to reside inside of a class. A function is therefore called a method. A method has a return value, a name and usually some parameters initialized when it is called with some arguments. It can either belong to an instance of a class or be a static member. A method is called using notation on a specific variable, or as in the case of static methods, the name of a type.

and parameters

One can explicitly make arguments be passed by reference when calling a method with parameters preceded by keywords or. These managed pointers come in handy when passing variables that one wants to be modified inside the method by reference. The main difference between the two is that an parameter must have been assigned within the method by the time the method returns. may or may not assign a new value, but the parameter variable has to be initialized before calling the function.

Optional parameters

C# 4.0 introduces optional parameters with default values as seen in C++. For example: In addition, to complement optional parameters, it is possible to explicitly specify parameter names in method calls, allowing to selectively pass any given subset of optional parameters for a method. The only restriction is that named parameters must be placed after the unnamed parameters. Parameter names can be specified for both optional and required parameters, and can be used to improve readability or arbitrarily reorder arguments in a call. For example: Optional parameters make interoperating with COM easier. Previously, C# had to pass in every parameter in the method of the COM component, even those that are optional. For example: With support for optional parameters, the code can be shortened as

A feature of C# is the ability to call native code. A method signature is simply declared without a body and is marked as. The attribute also needs to be added to reference the desired DLL file.

Fields

Fields, or instance variables, can be declared inside the class body to store data. Fields can be initialized directly when declared (unless declared in struct). Modifiers for fields:

Properties

Properties bring field-like syntax and combine them with the power of methods. A property can have two accessors: and. Modifiers for properties: Modifiers for property accessors: The default modifiers for the accessors are inherited from the property. Note that the accessor's modifiers can only be equal or more restrictive than the property's modifier.

Automatic properties

A feature of C# 3.0 is auto-implemented properties. Define accessors without bodies and the compiler will generate a backing field and the necessary code for the accessors.

Indexers

Indexers add array-like indexing capabilities to objects. They are implemented in a way similar to properties.

Inheritance

Classes in C# may only inherit from one class. A class may derive from any class that is not marked as.

Methods marked provide an implementation, but they can be overridden by the inheritors by using the keyword. The implementation is chosen by the actual type of the object and not the type of the variable.

When overloading a non-virtual method with another signature, the keyword may be used. The used method will be chosen by the type of the variable instead of the actual type of the object. This demonstrates the case:

Abstract classes are classes that only serve as templates and one cannot initialize an object of that type. Otherwise, it is just like an ordinary class. There may be abstract members too. Abstract members are members of abstract classes that do not have any implementation. They must be overridden by any non-abstract class that inherits the member.

The modifier can be combined with the others as an optional modifier for classes to make them uninheritable, or for methods to disallow overriding them in derived classes.

Interfaces

Interfaces are data structures that contain member definitions and not actual implementation. They are useful when one wants to define a contract between members in different types that have different implementations. One can declare definitions for methods, properties, and indexers. Interface members are implicitly public. An interface can either be implicitly or explicitly implemented.

Implementing an interface

An interface is implemented by a class or extended by another interface in the same way a class is derived from another class using the notation. Implicit implementation When implicitly implementing an interface the members of the interface have to be. In use: Explicit implementation One can also explicitly implement members. The members of the interface that are explicitly implemented by a class are accessible only when the object is handled as the interface type. In use: Note: The properties in the class that extends are auto-implemented by the compiler and a backing field is automatically added (see ). Extending multiple interfaces Interfaces and classes are allowed to extend multiple interfaces. Here is an interface that extends two interfaces.

Interfaces vs. abstract classes

Interfaces and abstract classes are similar. The following describes some important differences:

Generics

Generics (or parameterized types, parametric polymorphism) use type parameters, which make it possible to design classes and methods that do not specify the type used until the class or method is instantiated. The main advantage is that one can use generic type parameters to create classes and methods that can be used without incurring the cost of runtime casts or boxing operations, as shown here: When compared with C++ templates, C# generics can provide enhanced safety, but also have somewhat limited capabilities. For example, it is not possible to call arithmetic operators on a C# generic type. Unlike C++ templates, .NET parameterized types are instantiated at runtime rather than by the compiler; hence they can be cross-language whereas C++ templates cannot. They support some features not supported directly by C++ templates such as type constraints on generic parameters by use of interfaces. On the other hand, C# does not support non-type generic parameters. Unlike generics in Java, .NET generics use reification to make parameterized types first-class objects in the Common Language Infrastructure (CLI) Virtual Machine, which allows for optimizations and preservation of the type information.

Using generics

Generic classes

Classes and structs can be generic.

Generic interfaces

Generic delegates

Generic methods

Type-parameters

Type-parameters are names used in place of concrete types when defining a new generic. They may be associated with classes or methods by placing the type parameter in angle brackets. When instantiating (or calling) a generic, one can then substitute a concrete type for the type-parameter one gave in its declaration. Type parameters may be constrained by use of the keyword and a constraint specification, any of the six comma separated constraints may be used:

Covariance and contravariance

Generic interfaces and delegates can have their type parameters marked as covariant or contravariant, using keywords and , respectively. These declarations are then respected for type conversions, both implicit and explicit, and both compile-time and run-time. For example, the existing interface has been redefined as follows: Therefore, any class that implements for some class is also considered to be compatible with for all classes and interfaces that extends, directly, or indirectly. In practice, it makes it possible to write code such as: For contravariance, the existing interface has been redefined as follows: Therefore, any class that implements for some class is also considered to be compatible with for all classes and interfaces that are extended from. It makes it possible to write code such as:

Enumerators

An enumerator is an iterator. Enumerators are typically obtained by calling the method of an object implementing the interface. Container classes typically implement this interface. However, the foreach statement in C# can operate on any object providing such a method, even if it doesn't implement. This interface was expanded into generic version in .NET 2.0. The following shows a simple use of iterators in C# 2.0:

Generator functionality

The .NET 2.0 Framework allowed C# to introduce an iterator that provides generator functionality, using a construct similar to in Python. With a, the function automatically keeps its state during the iteration.

LINQ

LINQ, short for Language Integrated Queries, is a .NET Framework feature which simplifies the handling of data. Mainly it adds support that allows the querying of arrays, collections, and databases. It also introduces binders, which makes it easier to access to databases and their data.

Query syntax

The LINQ query syntax was introduced in C# 3.0 and lets one write SQL-like queries in C#. The statements are compiled into method calls, whereby almost only the names of the methods are specified. Which methods are ultimately used is determined by normal overload resolution. Thus, the end result of the translation is affected by what symbols are in scope. What differs from SQL is that the from-statement comes first and not last as in SQL. This is because it seems more natural writing like this in C# and supports "Intellisense" (Code completion in the editor).

Anonymous methods

Anonymous methods, or in their present form more commonly referred to as "lambda expressions", is a feature which allows programmers to write inline closure-like functions in their code. There are various ways to create anonymous methods. Prior to C# 3.0 there was limited support by using delegates.

Anonymous delegates

Anonymous delegates are functions pointers that hold anonymous methods. The purpose is to make it simpler to use delegates by simplifying the process of assigning the function. Instead of declaring a separate method in code the programmer can use the syntax to write the code inline and the compiler will then generate an anonymous function for it.

Lambda expressions

Lambda expressions provide a simple syntax for inline functions that are similar to closures. Functions with parameters infer the type of the parameters if other is not explicitly specified. Multi-statement lambdas have bodies enclosed by braces and inside of them code can be written like in standard methods. Lambda expressions can be passed as arguments directly in method calls similar to anonymous delegates but with a more aesthetic syntax. Lambda expressions are essentially compiler-generated methods that are passed via delegates. These methods are reserved for the compiler only and can not be used in any other context.

Extension methods

Extension methods are a form of syntactic sugar providing the illusion of adding new methods to the existing class outside its definition. In practice, an extension method is a static method that is callable as if it were an instance method; the receiver of the call is bound to the first parameter of the method, decorated with keyword :

Local functions

Local functions can be defined in the body of another method, constructor or property's getter and setter. Such functions have access to all variables in the enclosing scope, including parent method local variables. They are in scope for the entire method, regardless of whether they're invoked before or after their declaration. Access modifiers (public, private, protected) cannot be used with local functions. Also they do not support function overloading. It means there cannot be two local functions in the same method with the same name even if the signatures don't overlap. After a compilation, a local function is transformed into a private static method, but when defined it cannot be marked static. In code example below, the Sum method is a local function inside Main method. So it can be used only inside its parent method Main:

Miscellaneous

Closure blocks

C# implements closure blocks by means of the statement. The statement accepts an expression which results in an object implementing, and the compiler generates code that guarantees the object's disposal when the scope of the -statement is exited. The statement is syntactic sugar. It makes the code more readable than the equivalent block.

Thread synchronization

C# provides the statement, which is yet another example of beneficial syntactic sugar. It works by marking a block of code as a critical section by mutual exclusion of access to a provided object. Like the statement, it works by the compiler generating a block in its place.

Attributes

Attributes are entities of data that are stored as metadata in the compiled assembly. An attribute can be added to types and members like properties and methods. Attributes can be used for better maintenance of preprocessor directives. The .NET Framework comes with predefined attributes that can be used. Some of them serve an important role at runtime while some are just for syntactic decoration in code like. It does only mark that it is a compiler-generated element. Programmer-defined attributes can also be created. An attribute is essentially a class which inherits from the class. By convention, attribute classes end with "Attribute" in their name. This will not be required when using it. Showing the attribute in use using the optional constructor parameters.

Preprocessor

C# features "preprocessor directives" (though it does not have an actual preprocessor) based on the C preprocessor that allow programmers to define symbols, but not macros. Conditionals such as, , and are also provided. Directives such as give hints to editors for code folding. The block must be terminated with a directive.

Code comments

C# utilizes a double slash to indicate the rest of the line is a comment. Multi-line comments can be indicated by a starting slash/asterisk and ending asterisk/forward slash. Comments do not nest. These are two single comments: Single-line comments beginning with three slashes are used for XML documentation. This, however, is a convention used by Visual Studio and is not part of the language definition:

XML documentation comments

C#'s documentation comments are similar to Java's Javadoc, but based on XML. Two methods of documentation are currently supported by the C# compiler. Single-line documentation comments, such as those commonly found in Visual Studio generated code, are indicated on a line beginning with. Multi-line documentation comments, while defined in the version 1.0 language specification, were not supported until the .NET 1.1 release. These comments are designated by a starting forward slash/asterisk/asterisk and ending asterisk/forward slash. There are some stringent criteria regarding white space and XML documentation when using the forward slash/asterisk/asterisk technique. This code block: produces a different XML comment than this code block: Syntax for documentation comments and their XML markup is defined in a non-normative annex of the ECMA C# standard. The same standard also defines rules for processing of such comments, and their transformation to a plain XML document with precise rules for mapping of Common Language Infrastructure (CLI) identifiers to their related documentation elements. This allows any C# integrated development environment (IDE) or other development tool to find documentation for any symbol in the code in a certain well-defined way.

Async-await syntax

As of .NET Framework 4 there is a task library that makes it easier to write parallel and multi-threaded applications through tasks. C# 5.0 has native language support for asynchrony. Consider this code that takes advantage of the task library directly: Here is the same logic written in the async-await syntax:

Dialects

Spec#

Spec# is a dialect of C# that is developed in parallel with the standard implementation from Microsoft. It extends C# with specification language features and is a possible future feature to the C# language. It also adds syntax for the code contracts API that was introduced in .NET Framework 4.0. Spec# is being developed by Microsoft Research. This sample shows two of the basic structures that are used when adding contracts to code.

Non-nullable types

Spec# extends C# with non-nullable types that simply checks so the variables of nullable types that has been set as non-nullable are not null. If is null then an exception will be thrown. In use:

Preconditions

Preconditions are checked before a method is executed.

Postconditions

Postconditions are conditions that are ensured to be correct when a method has been executed.

Checked exceptions

Spec# adds checked exceptions like those in Java. Checked exceptions are problematic, because when a lower-level function adds a new exception type, the whole chain of methods using this method at some nested lower level must also change its contract. This violates the open/closed principle.