C Sharp syntax

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 a code element. It can contain letters, digits and underscores, and is case sensitive. The language imposes the following restrictions on identifier names:

They cannot start with a digit;
They cannot start with a symbol, except for the at sign, which can be used to prefix keywords to allow them as identifiers;
They cannot contain more than 511 characters.

Identifier names may be prefixed by @, which allows the use of reserved keywords as identifiers, but the @ is not considered part of the identifier's name for most purposes; @name and name refer to the same identifier unless name is a keyword.
Microsoft offered naming conventions for identifiers in C#, recommending the use of PascalCase for the names of types and most type members, and camelCase for variables and for private or internal fields. These naming conventions are not enforced by the language.

Keywords

Keywords are words with syntactic meaning. The language has two types of keyword — contextual and reserved. Reserved keywords such as false or byte may only be used as keywords. Contextual keywords such as where or from are treated as keywords only in certain situations. If an identifier is needed that matches a reserved keyword, it is prefixed by an @ sign to distinguish it. For example, @out is interpreted as an identifier, whereas out is a keyword. This syntax facilitates reuse of .NET code written in other languages.
The following C# keywords are reserved words, of which there are 77.abstract, as, base, 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

Contextual keywords

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 partial and where, have meanings in multiple contexts. The following 42 C# keywords are contextual.add, allows, alias, and, ascending, args, async, await, by, descending, dynamic, equals, from, get, global, group, init, into, join, let, managed, nameof, nint, not, notnull, nuint, on, or, orderby, partial, record, remove, required, select, set, unmanaged, value, var, when, where, with, yield

Preprocessor directives

Although C# does not have a separate preprocessor, unlike C and C++ which use the C preprocessor, these 13 directives are processed as if there were one.#nullable, #if, #elif, #else, #endif, #define, #undef, #region, #endregion, #error, #warning, #line, #pragma

Literals

float
double
decimal

string

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.

int bin = 0b1101_0010_1011_0100;
int hex = 0x2F_BB_4A_F1;
int dec = 1_000_500_954;
double real = 1_500.200_2e-1_000;

Generally, separators may be put only between digit characters. It cannot be put at the beginning or the end of the value, next to the decimal in floating point values, next to the exponent character, or next to the type specifier.

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

int myInt; // Declaring an uninitialized variable called 'myInt', of type 'int'

Assigning

int myInt; // Declaring an uninitialized variable
myInt = 35; // Assigning the variable a value

Initialize

int myInt = 35; // Declaring and initializing the variable

Multiple variables of the same type can be declared and initialized in one statement.

int a, b; // Declaring multiple variables of the same type
int a = 2, b = 3; // Declaring and initializing multiple variables of the same type

Local variable type inference

C# 3.0 introduced type inference, allowing the type specifier of a variable declaration to be replaced by the keyword var, 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.

var myChars = new char ;
// equivalent to:
char myChars = new char ;
var myNums = new List;
// equivalent to:
List myNums = new List;

Constants

Constants are immutable values.

`const`

When declaring a local variable or a field with the const keyword as a prefix the value must be given when it is declared. Thereafter the value cannot change. They can either be declared in the context as a field or a local variable. Constants are implicitly static.

const double PI = 3.14;

This shows both uses of the keyword.

public class Foo

`readonly`

The readonly keyword does a similar thing to fields. Like fields marked as const their value 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 works only on fields. readonly 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:

void DoSomething

Program structure

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

Main method

Every program must have an entry point. The entry point of a C# application is the Main method. There can only be one declaration of this method, and it is a static method in a class. It usually returns void and is passed command-line arguments as an array of strings.

static void Main // string args can be omitted if the program doesn't have any command-line arguments.

The main method may return an integer value if specified.

static int Main

Async Main

This is a feature of C# 7.1.
Asynchronous Tasks can be awaited in the Main method by declaring the method's return type as Task.

static async Task Main

All combinations of Task, or Task, and with, or without, the string args parameter are supported.

Top-level statements

This is a feature of C# 9.0.
Similar to in scripting languages, top-level statements remove the ceremony of having to declare the Program class with a Main method.
Instead, statements can be written directly in one file, which is the program entry point. Code in other files must be defined in classes.
This was introduced to make C# less verbose, and thus more accessible.
using System;
Console.WriteLine;
Types are declared after the statements, and are available from the statements above them.

Namespaces

Namespaces are a part of a type name and are used to group and/or distinguish named entities from other ones.

System.IO.DirectoryInfo // DirectoryInfo is in the System.IO-namespace

A namespace is defined with the namespace keyword:

namespace FooNamespace

A namespace can be nested inside a namespace in three ways:

namespace FooNamespace

and:

namespace FooNamspace
namespace FooNamspace.BarNamespace

In C# 10 and later, namespaces can be defined using file-scoped declarations by doing the following:

namespace FooNamespace; // the brackets are omitted here in favor of a semicolon.

`using` directive

The using directive loads a specific namespace from a referenced assembly. It is usually placed in the top of a code file but it can be placed elsewhere, e.g. inside a class.

using System;
using System.Collections;

The directive can also be used to define another name for an existing namespace or type. This is useful when names are long.

using Net = System.Net;
using DirInfo = System.IO.DirectoryInfo;

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.

using static System.Console;
WriteLine;

directive

Since C# 10, it is legal to write directives to indicate a using directive once and apply it to all source files.

global using System;
global using Microsoft.Extensions.FileSystemGlobbing;

Operators

Operator overloading

Some operators can be overloaded by writing an overload method.

public static Foo operator+

These are the overloadable operators:

Operators
,,,,,,,	Unary operators
,,,,,,,,,	Binary operators
, `!=`,,, `<=`, `>=`	Comparison operators, must be overloaded in pairs

Assignment operators are combinations of a binary operator and the assignment operator and is evaluated using the ordinary operators, which can be overloaded.
Cast operators cannot be overloaded, but it is possible to define conversion operators.
Array indexing operator is not overloadable, but it is possible to define new indexers.

Conversion operators

The cast operator is not overloadable, but a conversion operator method can live 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 while the explicit operator requires it to be used.

Implicit conversion operator

class Foo
// Implicit conversion
Foo foo = 2;

Explicit conversion operator

class Foo
// Explicit conversion
Foo foo = 2;

`as` operator

The as 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.

Stream stream = File.Open;
FileStream fstream = stream as FileStream; // Will return an object.
String str = stream as String; // Will return null.

Null coalesce operator

The following:

return ifNotNullValue ?? otherwiseValue;

is shorthand for:

return ifNotNullValue != null ? ifNotNullValue : otherwiseValue;

Meaning that if the content of variable is not null, that content is returned, otherwise the content of variable is returned.
C# 8.0 introduces null-coalescing assignment, such that

variable ??= otherwiseValue;

is equivalent to

if variable = otherwiseValue;

Control structures

C# inherits most of the control structures of C/C++ and adds others such as the foreach statement.

Conditional structures

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

`if` statement

The if 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.
A simple one-line statement:

if ... ;

Multi-line with else-block :

if
...
else
...

Recommended coding conventions for an if-statement.

if
else if
else

`switch` statement

The switch construct serves as a filter for different values. Each value leads to a "case". Falling through case sections is not allowed and therefore the keyword break is typically used to end a case. An unconditional return in a case section can also be used to end a case. goto statements can be used to fall through from one case to the next. The default case handles all cases not explicitly handled by the construct.

switch

Iteration structures

Iteration statements are statements that repeatedly execute when a given condition evaluates as true.

`while` loop

while

`do ... while` loop

do
while ;

`for` loop

The for loop consists of three parts: declaration, condition and counter expression. All are optional.

for

Is equivalent to this code represented with a while statement, except here the variable is not local to the loop.

int i = 0;
while

`foreach` loop

The foreach statement is derived from the for 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 is returned in the context of the code block. When the block has been executed the next item is returned until there are no items remaining.

foreach

Jump statements

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

Labels and `goto` statement

Labels are given points in code that can be jumped to by using the goto statement.

start:
.......
goto start;

Note that the label need not be positioned after the goto statement; it may be before it in the source file.
The goto statement can be used in switch statements to jump from one case to another or to fall through from one case to the next.

switch

`break` statement

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

int e = 10;
for

`continue` statement

The continue statement discontinues the current iteration of the current control statement and begins the next iteration.

int ch;
while ) != -1)

The while 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:

throw new NotImplementedException;

statements

Exceptions are managed within blocks.

try
catch
finally

The statements within the try block are executed, and if any of them throws an exception, execution of the block is discontinued and the exception is handled by the catch block. There may be multiple catch blocks, in which case the first block with an exception variable whose type matches the type of the thrown exception is executed.
If no catch block matches the type of the thrown exception, the execution of the outer block containing the try... catch 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 catch 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 catch 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 finally block are always executed after the try and catch blocks, whether or not an exception was thrown.
Either a catch block, a finally block, or both, must follow the try 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 declared. The two kinds of types are 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 falls out of scope it is destroyed.

Structures

Structures are more commonly known as structs. Structs are user-defined value types that are declared using the struct keyword. They are 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.

struct Foo

The primitive data types are all structs.

Pre-defined types

Note: is not a struct and is not a primitive type.

Enumerations

Enumerated types are named values representing integer values.

enum Season

Enum variables are initialized by default to zero. They can be assigned or initialized to the named values defined by the enumeration type.

Season season;
season = Season.Spring;

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 does not throw an exception if the value is not specified by the type definition.

season = 2; // cast 2 to an enum-value of type Season.
season = season + 1; // Adds 1 to the value.
season = season + season2; // Adding the values of two enum variables.
int value = season; // Casting enum-value to integer value.
season++; // Season.Spring becomes Season.Summer.
season--; // Season.Summer becomes Season.Spring.

Values can be combined using the bitwise-OR operator.

Color myColors = Color.Green | Color.Yellow | Color.Blue;

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 as in C++ and Java.
An array in C# is what is called a dynamic array in C++.

int numbers = new int;
numbers = 2;
numbers = 5;
int x = numbers;

Initializers

Array initializers provide convenient syntax for initialization of arrays.

// Long syntax
int numbers = new int;
// Short syntax
int numbers2 = ;
// Inferred syntax
var numbers3 = new ;

Multi-dimensional arrays

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

int numbers = new int;
numbers = 2;
int numbers2 = new int ;

See also

Jagged array

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 private by default, but can be declared as public to be visible outside of the class or protected to be visible by any descendants of the class.

Strings

The class, or, represents an immutable sequence of unicode characters.
Actions performed on a string always return a new string.

string text = "Hello World!";
string substr = text.Substring;
string parts = text.Split;

The class can be used when a mutable "string" is wanted.

StringBuilder sb = new StringBuilder;
sb.Append;
sb.Append;
sb.AppendLine;

Interface

Interfaces are data structures that contain member definitions without implementations. A variable of an interface type is a reference to an instance of a class which implements this interface. See #Interfaces.

Delegates

C# provides type-safe object-oriented function pointers in the form of delegates.

class Program

Initializing the delegate with an anonymous method.

addition = delegate ;

Initializing the delegate with lambda expression.

addition = => a + b;

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 classic Visual Basic.

using System.Windows.Controls;
delegate void MouseEventHandler;
public class Button : Control

An event requires an accompanied event handler that is made from a special delegate that in a platform specific library such as Windows Presentation Foundation and Windows Forms usually takes two parameters: sender and 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.

public class MainWindow : System.Windows.Controls.Window

Custom event implementation is also possible:

private EventHandler _clickHandles = => ;
public event EventHandler Click

See also

Event-driven programming

Nullable types

Nullable types were introduced in C# 2.0 firstly to enable value types to be null.

int? n = 2;
n = null;
Console.WriteLine;

This is the same as using the struct.

Nullable n = 2;
n = null;
Console.WriteLine;

Pointers

C# has and allows pointers to selected types in unsafe context: methods and codeblock marked unsafe. These are syntactically the same as pointers in C and C++. However, runtime-checking is disabled inside unsafe blocks.

static void Main

Structs are required only to be pure structs with no members of a managed reference type, e.g. a string or any other class.

public struct MyStruct
public struct MyContainerStruct

In use:

MyContainerStruct x;
MyContainerStruct* ptr = &x;
byte value = ptr->Byte;

Dynamic

Type dynamic 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.
This feature takes advantage of the Dynamic Language Runtime and is designed with the goal of interoperation with dynamically typed languages like IronPython and IronRuby.
Dynamic-support also eases interoperation with COM objects.

dynamic x = new Foo;
x.DoSomething; // Will compile and resolved at runtime. An exception will be thrown if invalid.

Anonymous types

Anonymous types are nameless classes that are generated by the compiler. They are only consumable and yet useful in a scenario such as a LINQ query that returns an object on select 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.

var carl = new ; // Name of the type is only known by the compiler.
var mary = new ; // Same type as the expression above

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 into a value of a value type. Unboxing in C# requires an explicit type cast.
Example:

int foo = 42; // Value type.
object bar = foo; // foo is boxed to bar.
int foo2 = bar; // Unboxed back to value type.

Object-oriented programming

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 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 base class. This class contains the most common methods shared by all objects. Some of these are virtual and can be overridden.
Classes inherit either directly or indirectly through another base class.
Members
Some members of the Object class:

- Supports comparisons between objects.
- Performs cleanup operations before an object is automatically reclaimed.
- Gets the number corresponding to the value of the object to support the use of a hash table.
- Gets the Type of the current instance.
- Creates a human-readable text string that describes an instance of the class. Usually returns the type name.

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, some significant differences apply. 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 on the heap. Variables are references, managed pointers on the stack which point to the objects.
Structures differ from classes in other ways. For example, while both offer an implicit default constructor that takes no arguments, it cannot be redefined for structs. Explicitly defining a differently-parametrized constructor overrides the implicit default constructor in classes, but not in structs. All fields of a struct must be initialized in those constructors. Structs do not have finalizers and cannot inherit from another class like classes do. Implicitly, they are sealed and inherit from . Structs are more suitable for smaller amounts of data.

	Default constructor	Finalizer	Member initialization	Inheritance
Classes	not required '	yes	not required	yes
Structs	required '	no	required	not supported

Declaration

Class declaration:

class Foo

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 partial.

// File1.cs
partial class Foo
// File2.cs
partial class Foo

The usual reason for using partial classes is to split some class into programmer-maintained and tool-maintained parts, 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 new keyword. It has the same name as the class.

Foo foo = new Foo;
StreamReader sr = new StreamReader;

For structs it is optional to explicitly call a constructor because the default one is called automatically. It must be declared and it gets initialized with standard values.
To reduce boilerplate, if the type is given in a declaration, the constructor can be invoked with just new.

Foo foo = new;
StreamReader sr = new;

Object initializers

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

Person person = new Person
// Equal to
Person person = new Person;
person.Name = "John Doe";
person.Age = 39;

Collection initializers

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

List list = new List ;
// Equal to
List list = new List;
list.Add;
list.Add;
list.Add;
list.Add;

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.

string foo = "Hello";
string fooUpper = foo.ToUpper;

Accessing a static class member
Static members are accessed by using the name of the class or other type.

int r = String.Compare;

Accessing a member through a pointer
In unsafe code, members of a value referenced by a pointer are accessed with the operator as in C and C++.

POINT p;
p.X = 2;
p.Y = 6;
POINT* ptr = &p;
ptr->Y = 4;

Modifiers

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

Class modifiers

abstract - Specifies that a class serves only as a base class. It implemented in an inheriting class. Required for classes to have abstract methods.
sealed - Specifies that a class cannot be inherited.
Class member modifiers
abstract - Declares a method to be available in all derived non-abstract classes.
const - Specifies that a variable is a constant value that has to be initialized when it gets declared.
event - Declares an event.
extern - Specifies that a method signature without a body uses a DLL-import.
override - Specifies that a method or property declaration is an override of a virtual member or an implementation of a member of an abstract class.
readonly - Declares a field that can only be assigned values as part of the declaration or in a constructor in the same class.
unsafe - Specifies an unsafe context, which allows the use of pointers.
virtual - Specifies that a method or property declaration can be overridden by a derived class.
volatile - Specifies a field that can be modified by an external process and prevents an optimizing compiler from making guesses about the persistence of the current value of the field.
static modifier

The static 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.

public class Foo
// Calling the class method.
Foo.Something;

Access modifiers

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

public class Foo

	Unnested types	Members	Accessible to
`public`	yes	yes	all
`protected internal`	no	yes	same class, derived classes, and everything in the same assembly
`protected`	no	yes	same class and derived classes
`internal`	yes	yes	everything in the same assembly
`private protected`	no	yes	same class, and derived classes in the same assembly
`private`	no	yes	same class

Constructors

A constructor is a special method that is called 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 any value. Implicitly, they return the newly created object when called via the new 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.

class Foo

Constructors can be public, private, protected or internal.

Destructor

The destructor is called when the object is collected by the garbage collector to perform manual clean-up. The default destructor method called can be overridden.
The syntax is similar to that of constructors. The difference is that the name is preceded by a ~ and it cannot include parameters. Only one destructor can be declared.

class Foo

Finalizers are always private.

Methods

As in C and C++ functions group reusable code. The main difference is that functions, as 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 parameters initialized when it is called with arguments. It can belong either to an instance of a class or be static.

class Foo

A method is called using notation on a specific variable, or as in the case of static methods, the name of a type.

Foo foo = new Foo;
int r = foo.Bar;
Console.WriteLine;

`ref` and `out` parameters

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

void PassRef
int Z = 7;
PassRef;
void PassOut
int Q;
PassOut;

Optional parameters

C# 4.0 introduces optional parameters with default values as seen in C++. For example:

void Increment
int x = 0;
Increment; // dx takes the default value of 1
Increment; // dx takes the value 2

In addition, to complement optional parameters, it is possible to explicitly specify parameter names in method calls, to selectively pass a subset of optional parameters for a method. The only restriction is that named parameters must be placed after 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:

Stream OpenFile
OpenFile; // use default values for both "mode" and "access"
OpenFile; // use default value for "access"
OpenFile; // use default value for "mode"
OpenFile;
// name all parameters for extra readability,
// and use order different from method declaration

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:

object fileName = "Test.docx";
object missing = System.Reflection.Missing.Value;
doc.SaveAs;
console.writeline;

With support for optional parameters, the code can be shortened as

doc.SaveAs;

`extern`

C# can call native code. A method signature is declared without a body and is marked as extern. The attribute references the desired DLL.

static extern double Pow;

Fields

Fields, or instance variables, can be declared inside the class body to store data.

class Foo

Fields can be initialized directly when declared.

class Foo

Modifiers for fields:

const - Makes the field a constant.
private - Makes the field private.
protected - Makes the field protected.
public - Makes the field public.
readonly - Allows the field to be initialized only once in a constructor.
static - Makes the field a static member, i.e. a class variable.

Properties

Properties bring field-like syntax and combine them with methods. A property can have two accessors: get and set.

public class Person
// Using a property
var person = new Person;
person.Name = "Robert";

Modifiers for properties:

private - Makes the property private.
protected - Makes the property protected.
public - Makes the property public.
static - Makes the property a static member.

Modifiers for property accessors:

private - Makes the accessor private.
protected - Makes the accessor protected.
public - Makes the accessor public.

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

Auto-implemented properties use accessors without bodies so that the compiler generatea a backing field and the necessary code.

public double Width

Indexers

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

internal class IntList
// Using an indexer
IntList list = new IntList;
list = 2;

Inheritance

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

class A
class B : A

`virtual`

Methods marked virtual provide an implementation that can be overridden by inheritors by using the override keyword.
The implementation is chosen by the type of the object and not the type of the variable.

class Operation
class NewOperation : Operation

`new`

When overloading a non-virtual method with another signature, the keyword new may be used. The method used is chosen by the variable type instead of the object type.

class Operation
class NewOperation : Operation

This demonstrates the case:

NewOperation op = new NewOperation;
// Will call "double Do" in NewOperation
double d = op.Do;
Operation op_ = op;
// Will call "int Do" in Operation
int i = op_.Do;

`abstract`

Abstract classes are classes that serve as templates and cannot be initialized. Otherwise, it is just like an ordinary class.
Abstract members are members of abstract classes that have no implementation. They must be overridden by non-abstract classes that inherit the member.

abstract class Mammal
class Human : Mammal

`sealed`

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

internal sealed class Foo
public class Bar
public class Baz : Bar

Interfaces

Interfaces are data structures that contain member definitions, but not implementations. They are used to define a contract between members in different types that have different implementations. Definitions can be supplied for methods, properties, and indexers. Interface members are implicitly public. An interface can either be implicitly or explicitly implemented.

interface IBinaryOperation

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 public.

public class Adder : IBinaryOperation
public class Multiplier : IBinaryOperation

In use:

IBinaryOperation op = null;
double result;
// Adder implements the interface IBinaryOperation.
op = new Adder;
op.A = 2;
op.B = 3;
result = op.GetResult; // 5
// Multiplier also implements the interface.
op = new Multiplier;
op.A = 5;
op.B = 4;
result = op.GetResult; // 20

Explicit implementation
Explicitly implemented members are accessible only when the object is handled as the interface type.

public class Adder : IBinaryOperation

In use:

Adder add = new Adder;
// These members are not accessible:
// add.A = 2;
// add.B = 3;
// double result = add.GetResult;
// Cast to the interface type to access them:
IBinaryOperation add2 = add;
add2.A = 2;
add2.B = 3;
double result = add2.GetResult;

Properties in the class that extends are auto-implemented by the compiler and a backing field is automatically added.
Extending multiple interfaces
Interfaces and classes are allowed to extend multiple interfaces.

class MyClass : IInterfaceA, IInterfaceB

An interface that extends two interfaces.

interface IInterfaceC : IInterfaceA, IInterfaceB

Interfaces vs. abstract classes

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

An abstract class may have member variables as well as non-abstract methods or properties. An interface cannot.
A class or abstract class can only inherit from one class or abstract class.
A class or abstract class may implement one or more interfaces.
An interface can extend only other interfaces.
An abstract class may have non-public methods and properties. An interface can have only public members.
An abstract class may have constants, static methods and static members. An interface cannot.
An abstract class may have constructors. An interface cannot.

Generics

Generics 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:

// Declare the generic class.
public class GenericList
class TestGenericList

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 Virtual Machine, which allows for optimizations and preservation of the type information.

Using generics

Generic classes

Classes and structs can be generic.

public class List
var list = new List;
list.Add;
list.Add;

Generic interfaces

interface IEnumerable

Generic delegates

delegate R Func;

Generic methods

public static T CombineArrays
string a = new string ;
string b = new string ;
string c = CombineArrays;
double da = new double ;
double db = new double ;
double dc = CombineArrays;
// c is a string array containing
// dc is a double array containing

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 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 where keyword and a constraint specification, any of the six comma separated constraints may be used:

Constraint	Explanation
	type parameter must be a value type
	type parameter must be a reference type
	type parameter must have a constructor with no parameters
	type parameter must inherit from
	type parameter must be, or must implement this interface
	naked type parameter constraint

Covariance and contravariance

Generic interfaces and delegates can have their type parameters marked as covariant or contravariant, using keywords out and in, 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:

interface IEnumerable

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:

void PrintAll
IEnumerable strings = new List;
PrintAll; // IEnumerable is implicitly converted to IEnumerable

C Sharp syntax

Basics

Identifier

Keywords

Keywords

Contextual keywords

Preprocessor directives

Literals

Digit separators

Variables

Local variable type inference

Constants

const

readonly

Code blocks

Program structure

Main method

Async Main

Top-level statements

Namespaces

using directive

directive

directive

Operators

Operator overloading

Conversion operators

Implicit conversion operator

Explicit conversion operator

as operator

Null coalesce operator

Control structures

Conditional structures

if statement

switch statement

Iteration structures

while loop

do ... while loop

for loop

foreach loop

Jump statements

Labels and goto statement

break statement

continue statement

Exception handling

statements

Types

Value types

Structures

Pre-defined types

Enumerations

Arrays

Initializers

Multi-dimensional arrays

Classes

Strings

Interface

Delegates

Events

Nullable types

Pointers

Dynamic

Anonymous types

Boxing and unboxing

Object-oriented programming

Objects

Object class

Classes

Differences between classes and structs

Declaration

Partial class

Initialization

Object initializers

Collection initializers

Accessing members

Modifiers

Class modifiers

Class member modifiers

static modifier

Access modifiers

Constructors

`const`

`readonly`

`using` directive

`as` operator

`if` statement

`switch` statement

`while` loop

`do ... while` loop

`for` loop

`foreach` loop

Labels and `goto` statement

`break` statement

`continue` statement

`static` modifier

`ref` and `out` parameters

`extern`

`virtual`

`new`

`abstract`

`sealed`