[<< wikibooks] C Sharp Programming/Print version
= Introduction =
C# (pronounced "See Sharp") is a multi-purpose computer programming language suitable for all development needs.

== Introduction ==
Although C# is derived from the C programming language, it has features such as garbage collection that allow beginners to become proficient in C# more quickly than in C or C++. Similar to Java, it is object-oriented, comes with an extensive class library, and supports exception handling, multiple types of polymorphism, and separation of interfaces from implementations. Those features, combined with its powerful development tools, multi-platform support, and generics, make C# a good choice for many types of software development projects: rapid application development projects, projects implemented by individuals or large or small teams, Internet applications, and projects with strict reliability requirements. Testing frameworks such as NUnit make C# amenable to test-driven development and thus a good language for use with Extreme Programming (XP). Its strong typing helps to prevent many programming errors that are common in weakly typed languages. Because of these similarities to other languages, it is possible to introduce C# as a language with features of C++ in addition to having the programming style of Java and the rapid application model of BASIC.A large part of the power of C# (as with other .NET languages), comes with the common .NET Framework API, which provides a large set of classes, including ones for encryption, TCP/IP socket programming, and graphics. Developers can thus write part of an application in C# and another part in another .NET language (e.g. VB.NET), keeping the tools, library, and object-oriented development model while only having to learn the new language syntax.
Because of the similarities between C# and the C family of languages, as well as Java, a developer with a background in object-oriented languages like C++ may find C# structure and syntax intuitive.

== Standard ==
Microsoft, with Anders Hejlsberg as Chief Engineer, created C# as part of their .NET initiative and subsequently opened its specification via the ECMA. Thus, the language is open to implementation by other parties. Other implementations include Mono and DotGNU.
C# and other .NET languages rely on an implementation of the virtual machine specified in the Common Language Infrastructure, like Microsoft's Common Language Runtime (CLR). CLR, for example, manages memory, handles object references, and performs Just-In-Time (JIT) compiling of Common Intermediate Language code. The virtual machine makes C# programs safer than those that must manage their own memory and is one of the reasons .NET language code is referred to as managed code. More like Java than C and C++, C# discourages explicit use of pointers, which could otherwise allow software bugs to corrupt system memory and force the operating system to halt the program forcibly with nondescript error messages.

== History ==
Microsoft's original plan was to create a rival to Java, named J++, but this was abandoned to create C#, codenamed "Cool". 
Microsoft submitted C# to the ECMA standards group mid-2000.
C# 2.0 was released in late-2005 as part of Microsoft's development suite, Visual Studio 2005. The 2.0 version of C# includes such new features as generics, partial classes, and iterators.

== References ==
To compile your first C# application, you will need a copy of a .NET Framework SDK installed on your PC.
There are two .NET frameworks available: Microsoft's and Mono's.

== Microsoft .NET ==
For Windows, the .NET Framework SDK can be downloaded from Microsoft's .NET Framework Developer Center. If the default Windows directory (the directory where Windows or WinNT is installed) is C:\WINDOWS, the .Net Framework SDK installation places the Visual C# .NET compiler (csc) in the
C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705  directory for version 1.0, the 
C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322 directory for version 1.1, the 
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727 directory for version 2.0, the
C:\WINDOWS\Microsoft.NET\Framework\v3.0  directory for version 3.0, the
C:\WINDOWS\Microsoft.NET\Framework\v3.5  directory for version 3.5, or the
C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319  directory for version 4.0.

== Mono ==
For Windows, Linux, or other Operating Systems, an installer can be downloaded from the Mono website. The Mono C# compiler is called mcs. 

=== Linux ===
In Linux you can use the MonoDevelop IDE, and either download from their website at: MonoDevelop Downloads, or install via apt-get or your distro's installer.

Debian-based distros:sudo apt-get install monodevelop
Arch Linux:sudo pacman -S mono monodevelop

=== Windows ===
You can download MonoDevelop from their website at: Mono website. Click the Windows icon, and follow the installation instructions.
If you are working on Windows it is a good idea to add the path to the folders that contain cs.exe or mcs.exe to the Path environment variable so that you do not need to type the full path each time you want to compile.
For writing C#.NET code, there are plenty of editors that are available.  It's entirely possible to write C#.NET programs with a simple text editor, but it should be noted that this requires you to compile the code yourself.  Microsoft offers a wide range of code editing programs under the Visual Studio line that offer syntax highlighting as well as compiling and debugging capabilities.   Currently C#.NET can be compiled in Visual Studio 2002 and 2003 (only supports the .NET Framework version 1.0 and 1.1) and Visual Studio 2005 (supports the .NET Framework 2.0 and earlier versions with some tweaking).  Microsoft offers five Visual Studio editions, four of which are sold commercially.  The Visual Studio C# Express Edition can be downloaded and used for free from Microsoft's website.

== Hello, World! ==
The code below will demonstrate a C# program written in a simple text editor.  Start by saving the following code to a text file called hello.cs:

To compile hello.cs, run the following from the command line:

For standard Microsoft installations of .NET 2.0,first cd into the directory with your source file then run C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\csc.exe hello.cs
For Mono run mcs hello.cs.
For users of cscc, compile with cscc hello.cs -o hello.exe.Doing so will produce hello.exe. The following command will run hello.exe:

On Windows, use hello.exe.
On Linux, use mono hello.exe or ilrun hello.exe.Alternatively, in Visual C# express, you could just hit F5 or the green play button to run the code. If you want to run without debugging, press CTRL-F5. 
Running hello.exe will produce the following output:


The program will then wait for you to strike 'enter' before returning to the command prompt.
Note that the example above includes the System namespace via the using keyword. That inclusion allows direct references to any member of the System namespace without specifying its fully qualified name.
The first call to the WriteLine method of the Console class uses a fully qualified reference.

The second call to that method shortens the reference to the Console class by taking advantage of the fact that the System namespace is included (with using System).

C# is a fully object-oriented language. The following sections explain the syntax of the C# language as a beginner's course for programming in the language. Note that much of the power of the language comes from the classes provided with the .NET framework, which are not part of the C# language syntax per se.

= Language Basics =
This section will define the naming conventions that are generally accepted by the C# development community. Some companies may define naming conventions that differ from this, but that is done on an individual basis and is generally discouraged. Some of the objects discussed in this section may be beyond the reader's knowledge at this point, but this section can be referred back to later.

== Reasoning ==
Much of the naming standards are derived from Microsoft's .NET Framework libraries. These standards have proven to make names readable and understandable "at a glance". By using the correct conventions when naming objects, you ensure that other C# programmers who read your code will easily understand what objects are without having to search your code for their definition.

== Conventions ==

=== Namespace ===
Namespaces are named using Pascal Case (also called UpperCamelCase) with no underscores. This means the first letter of every word in the name is capitalized. For example: MyNewNamespace. Pascal Case also means that acronyms of three or more letters should only have the first letter capitalized (MyXmlNamespace instead of MyXMLNamespace).

=== Assemblies ===
If an assembly contains only one namespace, the assembly and the namespace should use the same name. Otherwise, assemblies should follow the normal Pascal Case format.

=== Classes and Structures ===
Pascal Case, no underscores or leading C, cls, or I. Classes should not have the same name as the namespace in which they reside. Any acronyms of three or more letters should be Pascal Case, not all caps. Try to avoid abbreviations, and try to always use nouns.

=== Exception Classes ===
Follow class naming conventions, but add Exception to the end of the name. In .Net 2.0, all classes should inherit from the System.Exception base class, and not inherit from the System.ApplicationException.

=== Interfaces ===
Follow class naming conventions, but start the name with I and capitalize the letter following the I. Example: IFoo The I prefix helps to differentiate between Interfaces and classes and also to avoid name collisions.

=== Functions ===
Pascal Case, no underscores except in the event handlers. Try to avoid abbreviations. Many programmers have a nasty habit of overly abbreviating everything. This should be discouraged.

=== Properties and Public Member Variables ===
Pascal Case, no underscores. Try to avoid abbreviations.

=== Parameters and Procedure-level Variables ===
Camel Case (or lowerCamelCase). Try to avoid abbreviations. Camel Case is the same as Pascal case, but the first letter of the first word is lowercased.

=== Class-level Private and Protected Variables ===
Camel Case with a leading underscore. Always indicate protected or private in the declaration. The leading underscore is the only controversial thing in this document. The leading character helps to prevent name collisions in constructors (a parameter and a private variable having the same name).

=== Controls on Forms ===
Pascal Case with a prefix that identifies it as being part of the UI instead of a purely coded control (example a temporary variable). Many developers use ui as the prefix followed by a descriptive name such as txtUserName or lblUserNickName ("txt" stands for TextBox control and "lbl" for Label control)
This is in effect Camel Case; furthermore, this naming convention is known as Hungarian naming convention and is typically discouraged in modern programming. Variables in this style have names like lblSurname or tbSurname, rather than surnameLabel or surnameTextBox. This has the added advantage that similar UI elements are listed alphabetically contiguously in IntelliSense. 
Some samples are below for ASP.Net web form controls:

=== Constants ===
Pascal Case. The use of SCREAMING_CAPS is discouraged. This is a large change from earlier conventions. Most developers now realize that in using SCREAMING_CAPS they betray more implementation than is necessary. A large portion of the .NET Framework Design Guidelines is dedicated to this discussion.

== Example ==
Here is an example of a class that uses all of these naming conventions combined.

C# syntax looks quite similar to the syntax of Java because both inherit much of their syntax from C and C++. The object-oriented nature of C# requires the high-level structure of a C# program to be defined in terms of classes, whose detailed behaviors are defined by their statements.

== Statements ==
The basic unit of execution in a C# program is the statement. A statement can declare a variable, define an expression, perform a simple action by calling a method, control the flow of execution of other statements, create an object, or assign a value to a variable, property, or field. Statements are usually terminated by a semicolon.
Statements can be grouped into comma-separated statement lists or brace-enclosed statement blocks.

== Statement blocks ==
A series of statements surrounded by curly braces form a block of code. Among other purposes, code blocks serve to limit scope, or the range in which a variable can be used. A variable is only accessible in the block in which it is defined. Code blocks can be nested and often appear as the bodies of methods.

== Comments ==
Comments allow inline documentation of source code. The C# compiler ignores comments. These styles of comments are allowed in C#:

Single-line comments
The // character sequence marks the following text as a single-line comment. Single-line comments, as one would expect, end at the first end-of-line following the // comment marker.
Multiple-line comments
Comments can span multiple lines by using the multiple-line comment style. Such comments start with /* and end with */. The text between those multi-line comment markers is the comment.
XML Documentation-line comments
These comments are used to generate XML documentation. Single-line and multiple-line styles can be used. The single-line style, where each line of the comment begins with ///, is more common than the multiple-line style delimited by /** and */.

== Case sensitivity ==
C# is case-sensitive, including its variable and method names.
The variables myInteger and MyInteger of type int below are distinct because C# is case-sensitive:

For example, C# defines a class Console to handle most operations with the console window. Writing the following code would result in a compiler error unless an object named console had been previously defined.

The following corrected code compiles as expected because it uses the correct case:

Variables are used to store values. More technically, a variable binds an object (in the general sense of the term, i.e. a specific value) to an identifier (the variable's name) so that the object can be accessed later. Variables can, for example, store a value for later use:

In this example "name" is the identifier and "Dr. Jones" is the value that we bound to it. Also, each variable is declared with an explicit type. Only values whose types are compatible with the variable's declared type can be bound to (stored in) the variable. In the above example we stored "Dr. Jones" into a variable of the type string. This is a legal statement. However, if we had said int name = "Dr. Jones", the compiler would have thrown an error telling us that you cannot implicitly convert between int and string. There are methods for doing this, but we will talk about them later.

== Fields, local variables, and parameters ==
C# supports several program elements corresponding to the general programming concept of variable: fields, parameters, and local variables.

=== Fields ===
Fields, sometimes called class-level variables, are variables associated with classes or structures. An instance variable is a field associated with an instance of the class or structure, while a static variable, declared with the static keyword, is a field associated with the type itself. Fields can also be associated with their class by making them constants (const), which requires a declaration assignment of a constant value and prevents subsequent changes to the field.
Each field has a visibility of public, protected, internal, protected internal, or private (from most visible to least visible).

=== Local variables ===
Like fields, local variables can optionally be constant (const). Constant local variables are stored in the assembly data region, while non-constant local variables are stored on (or referenced from) the stack. They thus have both a scope and an extent of the method or statement block that declares them.

=== Parameter ===
Parameters are variables associated with a method.
An in parameter may either have its value passed in from the caller to the method's environment, so that changes to the parameter by the method do not affect the value of the caller's variable, or passed in by reference, so that changes to the variables will affect the value of the caller's variable.  Value types (int, double, string) are passed in "by value" while reference types (objects) are passed in "by reference." Since this is the default for the C# compiler, it is not necessary to use '&', as in C or C++.
An out parameter does not have its value copied, thus changes to the variable's value within the method's environment directly affect the value from the caller's environment. Such a variable is considered by the compiler to be unbound upon method entry, thus it is illegal to reference an out parameter before assigning it a value. It also must be assigned by the method in each valid (non-exceptional) code path through the method in order for the method to compile.
A reference parameter is similar to an out parameter, except that it is bound before the method call and it need not be assigned by the method.
A params parameter represents a variable number of parameters. If a method signature includes one, the params argument must be the last argument in the signature.

== Types ==
Each type in C# is either a value type or a reference type. C# has several predefined ("built-in") types and allows for declaration of custom value types and reference types.
There is a fundamental difference between value types and reference types: Value types are allocated on the stack, whereas reference types are allocated on the heap.

=== Value types ===
The value types in the .NET framework are usually small, frequently used types. The benefit of using them is that the type requires very little resources to get up and running by the CLR. Value types do not require memory to be allocated on the heap and therefore will not cause garbage collection. However, in order to be useful, the value types (or types derived from it) should remain small - ideally below 16 bytes of data. If you choose to make your value type bigger, it is recommended that you do not pass it to methods (which can require a copy of all its fields), or return it from methods.
Although this sounds like a useful type to have, it does have some flaws, which need to be understood when using it.

Value types are always copied (intrinsically) before being passed to a method. Changes to this new object will not be reflected back in the original object passed into the method.
Value types do not /need/ you to call their constructor. They are automatically initialized.
Value types always initialize their fields to 0 or null.
Value types can NEVER be assigned a value of null (but can using Nullable types)
Value types sometimes need to be boxed (wrapped inside an object), allowing their values to be used like objects.

=== Reference types ===
Reference types are managed very differently by the CLR. All reference types consist of two parts: A pointer to the heap (which contains the object), and the object itself. Reference types are slightly heavier weight because of the management behind the scenes needed to keep track of them. However, this is a minor price to pay for the flexibility and speed gains from passing a pointer around, rather than copying values to/from methods. 
When an object is initialized, by use of the constructor, and is of a reference type, the CLR must perform four operations:

The CLR calculates the amount of memory required to hold the object on the heap.
The CLR inserts the data into the newly created memory space.
The CLR marks where the end of the space lies, so that the next object can be placed there.
The CLR returns a reference to the newly created space.This occurs every single time an object is created. However the assumption is that there is infinite memory, therefore some maintenance needs to take place - and that's where the garbage collector comes in.

=== Integral types ===
Because the type system in C# is unified with other languages that are CLI-compliant, each integral C# type is actually an alias for a corresponding type in the .NET framework. Although the names of the aliases vary between .NET languages, the underlying types in the .NET framework remain the same. Thus, objects created in assemblies written in other languages of the .NET Framework can be bound to C# variables of any type to which the value can be converted, per the conversion rules below. The following illustrates the cross-language compatibility of types by comparing C# code with the equivalent Visual Basic .NET code:

Using the language-specific type aliases is often considered more readable than using the fully-qualified .NET Framework type names.
The fact that each C# type corresponds to a type in the unified type system gives each value type a consistent size across platforms and compilers. That consistency is an important distinction from other languages such as C, where, e.g. a long is only guaranteed to be at least as large as an int, and is implemented with different sizes by different compilers. As reference types, variables of types derived from object (i.e. any class) are exempt from the consistent size requirement. That is, the size of reference types like System.IntPtr, as opposed to value types like System.Int32, may vary by platform. Fortunately, there is rarely a need to know the actual size of a reference type.
There are two predefined reference types: object, an alias for the System.Object class, from which all other reference types derive; and string, an alias for the System.String class. C# likewise has several integral value types, each an alias to a corresponding value type in the System namespace of the .NET Framework. The predefined C# type aliases expose the methods of the underlying .NET Framework types. For example, since the .NET Framework's System.Int32 type implements a ToString() method to convert the value of an integer to its string representation, C#'s int type exposes that method:

Likewise, the System.Int32 type implements the Parse() method, which can therefore be accessed via C#'s int type:

The unified type system is enhanced by the ability to convert value types to reference types (boxing) and likewise to convert certain reference types to their corresponding value types (unboxing). This is also known as casting.

Boxing and casting are, however, not type-safe: the compiler won't generate an error if the programmer mixes up the types. In the following short example the mistake is quite obvious, but in complex programs it may be very difficult to spot. Avoid boxing, if possible.

The built-in C# type aliases and their equivalent .NET Framework types follow:

==== Integers ====

==== Floating-point ====

==== Other predefined types ====

=== Custom types ===
The predefined types can be aggregated and extended into custom types.
Custom value types are declared with the struct or enum keyword. Likewise, custom reference types are declared with the class keyword.

==== Arrays ====
Although the number of dimensions is included in array declarations, the size of each dimension is not:

Assignments to an array variable (prior to the variable's usage), however, specify the size of each dimension:

As with other variable types, the declaration and the initialization can be combined:

It is also important to note that like in Java, arrays are passed by reference, and not passed by value. For example, the following code snippet successfully swaps two elements in an integer array:

It is possible to determine the array size during runtime. The following example assigns the loop counter to the unsigned short array elements:

Since C# 2.0, it is possible to have arrays also inside of structures.

== Text & variable example ==

=== Conversion ===
Values of a given type may or may not be explicitly or implicitly convertible to other types depending on predefined conversion rules, inheritance structure, and explicit cast definitions.

==== Predefined conversions ====
Many predefined value types have predefined conversions to other predefined value types.  If the type conversion is guaranteed not to lose information, the conversion can be implicit (i.e. an explicit cast is not required).

==== Inheritance polymorphism ====
A value can be implicitly converted to any class from which it inherits or interface that it implements. To convert a base class to a class that inherits from it, the conversion must be explicit in order for the conversion statement to compile. Similarly, to convert an interface instance to a class that implements it, the conversion must be explicit in order for the conversion statement to compile. In either case, the runtime environment throws a conversion exception if the value to convert is not an instance of the target type or any of its derived types.

== Scope and extent ==
The scope and extent of variables is based on their declaration. The scope of parameters and local variables corresponds to the declaring method or statement block, while the scope of fields is associated with the instance or class and is potentially further restricted by the field's access modifiers.
The extent of variables is determined by the runtime environment using implicit reference counting and a complex garbage collection algorithm.
C# operators and their precedence closely resemble the operators in other languages of the C family.
Similar to C++, classes can overload most operators, defining or redefining the behavior of the operators in contexts where the first argument of that operator is an instance of that class, but doing so is often discouraged for clarity.
Operators can be grouped by their arity as nullary, unary, binary, ternary, n-ary.
Following are the built-in behaviors of C# operators.

== Arithmetic ==
The following arithmetic operators operate on numeric operands (arguments a and b in the "expression" below).

== Logical ==
The following logical operators operate on boolean or integral operands, as noted.

== Bitwise shifting ==

== Relational ==
The binary relational operators ==, !=, <, >, <=, and >= are used for relational operations and for type comparisons.

== Assignment ==
The most basic is the operator =. Not surprisingly, it assigns the value (or reference) of its second argument to its first argument. As such, the assignment operator is binary, but has an n-ary form.
(More technically, the operator = requires for its first (left) argument an expression to which a value can be assigned (an l-value) and for its second (right) argument an expression that can be evaluated (an r-value). That requirement of an assignable expression to its left and a bound expression to its right is the origin of the terms l-value and r-value.)
The first argument of the assignment operator (=) is typically a variable. When that argument has a value type, the assignment operation changes the argument's underlying value. When the first argument is a reference type, the assignment operation changes the reference, so the first argument typically just refers to a different object, but the object that it originally referenced does not change (except that it may no longer be referenced and may thus be a candidate for garbage collection).

== Short-hand Assignment ==
The short-hand assignment operators shortens the common assignment operation of a = a operator b into a operator= b, resulting in less typing and neater syntax.

== Type information ==

== Pointer manipulation ==
NOTE: Most C# developers agree that direct manipulation and use of pointers is not recommended in C#. The language has many built-in classes to allow you to do almost any operation you want. C# was built with memory-management in mind and the creation and use of pointers is greatly disruptive to this end. This speaks to the declaration of pointers and the use of pointer notation, not arrays. In fact, a program may only be compiled in "unsafe mode", if it uses pointers.

== Overflow exception control ==

== Others ==
There are various ways of grouping sets of data together in C#.

== Enumerations ==
An enumeration is a data type that enumerates a set of items by assigning to each of them an identifier (a name), while exposing an underlying base type for ordering the elements of the enumeration. The underlying type is int by default, but can be any one of the integral types except for char.
Enumerations are declared as follows:

The elements in the above enumeration are then available as constants:

If no explicit values are assigned to the enumerated items as the example above, the first element has the value 0, and the successive values are assigned to each subsequent element. However, specific values from the underlying integral type can be assigned to any of the enumerated elements (note that the variable must be type cast in order to access the base type):

The underlying values of enumerated elements may go unused when the purpose of an enumeration is simply to group a set of items together, e.g., to represent a nation, state, or geographical territory in a more meaningful way than an integer could. Rather than define a group of logically related constants, it is often more readable to use an enumeration.
It may be desirable to create an enumeration with a base type other than int. To do so, specify any integral type besides char as with base class extension syntax after the name of the enumeration, as follows:

The enumeration type is also helpful, if you need to output the value. By calling the .ToString() method on the enumeration, will output the enumerations name (e.g. CardSuit.Hearts.ToString() will output "Hearts").

== Structs ==
Structures (keyword struct) are light-weight objects. They are mostly used when only a data container is required for a collection of value type variables.  Structs are similar to classes in that they can have constructors, methods, and even implement interfaces, but there are important differences.

Structs are value types while classes are reference types, which means they behave differently when passed into methods as parameters.
Structs cannot support inheritance.  While structs may appear to be limited with their use, they require less memory and can be less expensive, if used in the proper way.
Structs always have a default constructor, even if you don't want one. Classes allow you to hide the constructor away by using the "private" modifier, whereas structures must have one.A struct can, for example, be declared like this:

The Person struct can then be used like this:

It is also possible to provide constructors to structs to make it easier to initialize them:

There is also an alternative syntax for initializing structs:

Structs are really only used for performance reasons or, if you intend to reference it by value. Structs work best when holding a total equal to or less than 16 bytes of data. If in doubt, use classes.

== Arrays ==
Arrays represent a set of items all belonging to the same type. The declaration itself may use a variable or a constant to define the length of the array. However, an array has a set length and it cannot be changed after declaration.

Conditional, iteration, jump, and exception handling statements control a program's flow of execution.
A conditional statement can decide something using keywords such as if, switch.
An iteration statement can create a loop using keywords such as do, while, for, foreach, and in.
A jump statement can be used to transfer program control using keywords such as break, continue, return, and yield.

== Conditional statements ==
A conditional statement decides whether to execute code based on conditions. The if statement and the switch statement are the two types of conditional statements in C#.

=== if statement ===
As with most of C#, the if statement has the same syntax as in C, C++, and Java. Thus, it is written in the following form:

The if statement evaluates its condition expression to determine whether to execute the if-body. Optionally, an else clause can immediately follow the if body, providing code to execute when the condition is false. Making the else-body another if statement creates the common cascade of if, else if, else if, else if, else statements:

=== switch statement ===
The switch statement is similar to the statement from C, C++ and Java.
Unlike C, each case statement must finish with a jump statement (that can be break or goto or return). In other words, C# does not support "fall through" from one case statement to the next (thereby eliminating a common source of unexpected behaviour in C programs). However "stacking" of cases is allowed, as in the example below. If goto is used, it may refer to a case label or the default case (e.g. goto case 0 or goto default).
The default label is optional. If no default case is defined, then the default behaviour is to do nothing. 
A simple example:

A nice improvement over the C switch statement is that the switch variable can be a string. For example:

== Iteration statements ==
An iteration statement creates a loop of code to execute a variable number of times. The for loop, the do loop, the while loop, and the foreach loop are the iteration statements in C#.

=== do ... while loop ===
The do...while loop likewise has the same syntax as in other languages derived from C. It is written in the following form:

do...while-loop ::= "do" body "while" "(" condition ")"
condition ::= boolean-expression
body ::= statement-or-statement-blockThe do...while loop always runs its body once. After its first run, it evaluates its condition to determine whether to run its body again. If the condition is true, the body executes. If the condition evaluates to true again after the body has run, the body executes again. When the condition evaluates to false, the do...while loop ends.

The above code writes the integers from 0 to 10 to the console.

=== for loop ===
The for loop likewise has the same syntax as in other languages derived from C. It is written in the following form:

for-loop ::= "for" "(" initialization ";" condition ";" iteration ")" body
initialization ::= variable-declaration | list-of-statements
condition ::= boolean-expression
iteration ::= list-of-statements
body ::= statement-or-statement-blockThe initialization variable declaration or statements are executed the first time through the for loop, typically to declare and initialize an index variable. The condition expression is evaluated before each pass through the body to determine whether to execute the body. It is often used to test an index variable against some limit. If the condition evaluates to true, the body is executed. The iteration statements are executed after each pass through the body, typically to increment or decrement an index variable.

The above code writes the integers from 0 to 99 to the console.

=== foreach loop ===
The foreach statement is similar to the for statement in that both allow code to iterate over the items of collections, but the foreach statement lacks an iteration index, so it works even with collections that lack indices altogether. It is written in the following form:

foreach-loop ::= "foreach" "(" variable-declaration "in" enumerable-expression ")" body
body ::= statement-or-statement-blockThe enumerable-expression is an expression of a type that implements '''IEnumerable''', so it can be an array or a collection. The variable-declaration declares a variable that will be set to the successive elements of the enumerable-expression for each pass through the body. The foreach loop exits when there are no more elements of the enumerable-expression to assign to the variable of the variable-declaration.

In the above code, the foreach statement iterates over the elements of the string array to write "Alpha", "Bravo", and "Charlie" to the console.

=== while loop ===
The while loop has the same syntax as in other languages derived from C. It is written in the following form:

while-loop ::= "while" "(" condition ")" body
condition ::= boolean-expression
body ::= statement-or-statement-blockThe while loop evaluates its condition to determine whether to run its body. If the condition is true, the body executes. If the condition then evaluates to true again, the body executes again. When the condition evaluates to false, the while loop ends.

== Jump statements ==
A jump statement can be used to transfer program control using keywords such as break, continue, return, yield, and throw.

=== break ===
A break statement is used to exit from a case in a switch statement and also used to exit from for, foreach, while, do .. while loops that will switch the control to the statement immediately after the end of the loop.

=== continue ===
The continue keyword transfers program control just before the end of a loop. The condition for the loop is then checked, and if it is met, the loop performs another iteration.

=== return ===
The return keyword identifies the return value for the function or method (if any), and transfers control to the end of the function.

=== yield ===
The yield keyword is used to define an iterator block that produces values for an enumerator. It is typically used within a method
implementation of the IEnumerable interface as an easy way to create an iterator.
It is written in the following forms:

yield ::= "yield" "return" expression
yield ::= "yield" "break"The following example shows the usage of the yield keyword inside the method MyCounter. This method defines an iterator block, and will return an enumerator object that generates the value of a counter from zero to stop, incrementing by step for each value generated.

=== throw ===
The throw keyword throws an exception. If it is located within a try block, it will transfer the control to a catch block that matches the exception - otherwise, it will check if any calling functions are contained within the matching catch block and transfer execution there. If no functions contain a catch block, the program may terminate because of an unhandled exception. 

Exceptions and the throw statement are described in greater detail in the Exceptions chapter.

== Introduction ==
Software Programmers write code to perform some desired actions. But every software may fail to perform its desired actions for internal or external reasons. The exception handling system in the C# language allows the programmer to handle errors or anomalous situations in a structured manner that allows the programmer to separate the normal flow of the code from error-handling logic. 
An exception can represent a variety of abnormal conditions that arise during the execution of the software. Such conditions can be internal or externally caused. External conditions of execution failures include, for example, network failures in connecting to a remote component, inadequate rights in using a file/system resource, out of memory exceptions or exceptions thrown by a web service etc. These are mainly due to failures thrown by environment components on which our application depends, e.g. the operating system, the .NET runtime or external applications or components. Internal failures may be due to software defects, designed functional failures (failures required as per business rules), propagated external failures, e.g. a null object reference detected by the runtime system, an invalid input string entered by a user and detected by application code, or a user requesting to withdraw a larger amount than the account balance (business rule). 
Code that detects an error condition is said to throw an exception and code that handles the error is said to catch the exception. An exception in C# is an object that encapsulates various pieces of information about the error that occurred, such as the stack trace at the point of the exception and a descriptive error message. All exception objects are instantiations of the System.Exception class or a child class of it. There are many exception classes defined in the .NET Framework used for various purposes. Programmers may also define their own class inheriting from System.Exception or some other appropriate exception class from the .NET Framework.
Microsoft recommendations prior to version 2.0 recommended that a developer's exception classes should inherit from the ApplicationException exception class. After 2.0 was released, this recommendation was made obsolete and users' exception classes should now inherit from the Exception class.

== Overview ==
There are three code definitions for exception handling. These are:

try/catch - Do something and catch an error, if it should occur.
try/catch/finally - Do something and catch an error if it should occur, but always do the finally.
try/finally - Do something, but always do the finally. Any exception that occurs, will be thrown after finally.Exceptions are caught in the order from most specific to least specific. So for example, if you try and access a file that does not exist, the CLR would look for exception handlers in the following order:

IOException (base class of FileNotFoundException)
SystemException (base class of IOException)
Exception (base class of SystemException)If the exception being thrown does not derive from or is not in the list of exceptions to catch, it is thrown up the call stack.
Below are some examples of the different types of exceptions

== Examples ==

=== try/catch ===
The try/catch performs an operation and should an error occur, will transfer control to the catch block, should there be a valid section to be caught by:

Here is an example with multiple catches:

In all catch statements you may omit the type of exception and the exception variable name:

=== try/catch/finally ===
Catching the problem is a good idea, but it can sometimes leave your program in an invalid state. For example, if you open a connection to a database, an error occurs and you throw an exception. Where would you close the connection? In both the try AND exception blocks? Well, problems may occur before the close is carried out. 
Therefore, the finally statement allows you to cater for the "in all cases do this" circumstance. See the example below:

Second Example

Notice that the SqlConnection object is declared outside of the try/catch/finally. The reason is that anything declared in the try/catch cannot be seen by the finally. By declaring it in the previous scope, the finally block is able to access it.

=== try/finally ===
The try/finally block allows you to do the same as above, but instead errors that are thrown are dealt with by the catch (if possible) and then thrown up the call stack.

== Re-throwing exceptions ==
Sometimes it is better to throw the error up the call stack for two reasons.

It is not something you would expect to happen.
You are placing extra information into the exception, to help diagnosis.

=== How not to throw exceptions ===
Some developers write empty try/catch statements like this:

This approach is not recommended. You are swallowing the error and continuing on. If this exception was an OutOfMemoryException or a NullReferenceException, it would not be wise to continue. Therefore you should always catch what you would expect to occur, and throw everything else. 
Below is another example of how exceptions are caught incorrectly 

As you can see, the ConfigurationErrorsException will be caught by the catch (Exception) block, but it is being ignored completely! This is bad programming as you are ignoring the error. 
The following is also bad practice:

The CLR will now think the throw ex; statement is the source of the problem, when the problem is actually in the try section. Therefore never re-throw in this way.

=== How to catch exceptions ===
A better approach would be:

The throw; keyword means preserve the exception information and throw it up the call stack.

=== Extra information within exceptions ===
An alternative is to give extra information (maybe local variable information) in addition to the exception. In this case, you wrap the exception within another. You usually use an exception that is as specific to the problem as possible, or create your own, if you cannot find out that is not specific enough (or if there is extra information you would wish to include).

=== References ===

= Classes =
Namespaces are used to provide a "named space" in which your application resides. They're used especially to provide the C# compiler a context for all the named information in your program, such as variable names. Without namespaces, for example, you wouldn't be able to make a class named Console, as .NET already uses one in its System namespace. The purpose of namespaces is to solve this problem, and release thousands of names defined in the .NET Framework for your applications to use, along with making it so your application doesn't occupy names for other applications, if your application is intended to be used in conjunction with another. So namespaces exist to resolve ambiguities a compiler wouldn't otherwise be able to do.
Namespaces are easily defined in this way:

There is an entire hierarchy of namespaces provided to you by the .NET Framework, with the System namespace usually being by far the most commonly seen one. Data in a namespace is referred to by using the . operator, such as:

This will call the WriteLine method that is a member of the Console class within the System namespace.
By using the using keyword, you explicitly tell the compiler that you'll be using a certain namespace in your program. Since the compiler would then know that, it no longer requires you to type the namespace name(s) for such declared namespaces, as you told it which namespaces it should look in, if it couldn't find the data in your application.
So one can then type like this:

Namespaces are global, so a namespace in one C# source file, and another with the same name in another source file, will cause the compiler to treat the different named information in these two source files as residing in the same namespace.

== Nested namespaces ==
Normally, your entire application resides under its own special namespace, often named after your application or project name. Sometimes, companies with an entire product series decide to use nested namespaces though, where the "root" namespace can share the name of the company, and the nested namespaces the respective project names. This can be especially convenient, if you're a developer who has made a library with some usual functionality that can be shared across programs. If both the library and your program shared a parent namespace, that one would then not have to be explicitly declared with the using keyword, and still not have to be completely typed out. If your code was open for others to use, third party developers that may use your code would additionally then see that the same company had developed the library and the program. The developer of the library and program would finally also separate all the named information in their product source codes, for fewer headaches especially, if common names are used.
To make your application reside in a nested namespace, you can show this in two ways. Either like this:

... or like this:

Both methods are accepted, and are identical in what they do.

As in other object-oriented programming languages, the functionality of a C# program is implemented in 
one or more classes. The methods and properties of a class contain the code that defines how the class behaves.
C# classes support information hiding by encapsulating functionality in properties and methods and by enabling several types of polymorphism, including subtyping polymorphism via inheritance and parametric polymorphism via generics.
Several types of C# classes can be defined, including instance classes (standard classes that can be instantiated), static classes, and structures.
Classes are defined using the keyword class followed by an identifier to name the class. Instances of the class can then be created with the new keyword followed by the name of the class.
The code below defines a class called Employee with properties Name and Age and with empty methods GetPayCheck() and Work(). It also defines a Sample class that instantiates and uses the Employee class:

== Methods ==
C# methods are class members containing code. They may have a return value and a list of parameters, as well as a generic type declaration. Like fields, methods can be static (associated with and accessed through the class) or instance (associated with and accessed through an object instance of the class methods as well as a generic type declaration.
From C# 4.0 onwards, it is possible for a method to have optional parameters with default values, as users of C++ already know. For example, the method

can be called with one parameter only, as the second parameter, dx, is initialised to a default value.

== Constructors of classes ==
A class's constructors control its initialization. A constructor's code executes to initialize an instance of the class when a program requests a new object of the class's type. Constructors often set properties of their classes, but they are not restricted to doing so.
Like other methods, a constructor can have parameters. To create an object using a constructor with parameters, the new command accepts parameters. The code below defines and then instantiates multiple objects of the Employee class, once using the constructor without parameters and once using the version with a parameter:


Constructed without parameters
Parameter for construction

Constructors can call each other:

== Finalizers (Destructors) ==
The opposite of constructors, finalizers define the final behavior of an object and execute when the object is no longer in use. Although they are often used in C++ to free resources reserved by an object, they are less frequently used in C# due to the .NET Framework Garbage Collector. An object's finalizer, which takes no parameters, is called sometime after an object is no longer referenced, but the complexities of garbage collection make the specific timing of finalizers uncertain.



== Properties ==
C# properties are class members that expose functionality of methods using the syntax of fields. They simplify the syntax of calling traditional get and set methods (a.k.a. accessor methods). Like methods, they can be static or instance.
Properties are defined in the following way:

An even shorter way for getter/setter methods are accessors that do both in one line:

The code is equivalent to a GetLanguage and SetLanguage method definition, but without having to define these methods. The user can directly access the member, if it is not private, of course.
The C# keyword value contains the value assigned to the property. After a property is defined it can be used like a variable. If you were to write some additional code in the get and set portions of the property it would work like a method and allow you to manipulate the data before it is read or written to the variable.

Using properties in this way provides a clean, easy to use mechanism for protecting data.

== Indexers ==
C# indexers are class members that define the behavior of the array access operation (e.g. list[0] to access the first element of list even when list is not an array).
To create an indexer, use the this keyword as in the following example:

This code will create a string indexer that returns a string value. For example, if the class was EmployeeCollection, you could write code similar to the following:

== Events ==
C# events are class members that expose notifications to clients of the class. Events are only fired and never assigned.

See also here for details.

== Operator overloading ==
C# operator definitions are class members that define or redefine the behavior of basic C# operators (called implicitly or explicitly) on instances of the class:

== Structures ==
Structures, or structs, are defined with the struct keyword followed by an identifier to name the structure. They are similar to classes, but have subtle differences. Structs are used as lightweight versions of classes that can help reduce memory management efforts when working with small data structures. In most situations, however, using a standard class is a better choice.
The principal difference between structs and classes is that instances of structs are values whereas instances of classes are references. Thus when you pass a struct to a function by value you get a copy of the object so changes to it are not reflected in the original because there are now two distinct objects but if you pass an instance of a class by reference then there is only one instance.
The Employee structure below declares a public and a private field. Access to the private field is granted through the public property Name:

Since C# 2.0, is possible to have arrays inside structures, but only in unsafe contexts:

The array is accessed using pointer arithmetic. Values are treat arrayed values as if they were C-style arrays using indexing, etc.

=== Structure constructors ===
Structures need constructors - or better to say initialisers, as they do not construct but just initialise the memory - so that their contents are not left uninitialised. Therefore, constructors without parametres are not allowed.
Structure variables can be assigned one to another if and only if the structure variable on the right side of the assignment are all initialised.

== Static classes ==
Static classes are commonly used to implement a Singleton Pattern. All of the methods, properties, and fields of a static class are also static (like the WriteLine() method of the System.Console class) and can thus be used without instantiating the static class:

== References ==

== Introduction ==
The .NET framework consists of several languages, all which follow the "object orientated programming" (OOP) approach to software development. This standard defines that all objects support

Inheritance - the ability to inherit and extend existing functionality.
Encapsulation - the ability to allow the user to only see specific parts, and to interact with it in specific ways.
Polymorphism - the ability for an object to be assigned dynamically, but with some predictability as to what can be done with the object.Objects are synonymous with objects in the real world. Think of any object and think of how it looks and how it is measured and interacted with. When creating OOP languages, the reasoning was that if it mimics the thought process of humans, it would simplify the coding experience.
For example, let's consider a chair, and its dimensions, weight, colour and what is it made out of. In .NET, these values are called "Properties". These are values that define the object's state. Be careful, as there are two ways to expose values: Fields and Properties. The recommended approach is expose Properties and not fields.
So we have a real-world idea of the concept of an object. In terms of practicality for a computer to pass information about, passing around an object within a program would consume a lot of resources. Think of a car, how many properties that has - 100's, 1000's. A computer passing this information about all the time will waste memory, processing time and therefore a bad idea to use. So objects come in two flavours:

Reference types
Value types

== Reference and Value Types ==
A reference type is like a pointer to the value. Think of it like a piece of paper with a street address on it, and the address leads to your house - your object with hundreds of properties. If you want to find it, go to where the address says! This is exactly what happens inside the computer. The reference is stored as a number, corresponding to somewhere in memory where the object exists. So instead of moving an object around - like building a replica house every time you want to look at it - you just look at the original.
A value type is the exact value itself. Values are great for storing small amounts of information: numbers, dates etc.
There are differences in the way they are processed, so we will leave that until a little later in the article.
As well as querying values, we need a way to interact with the object so that some operation can be performed. Think of files - it's all well and good knowing the length of the file, but how about Read()'ing it? Therefore, we can use something called methods as a way of performing actions on an object.
An example would be a rectangle. The properties of a rectangle are:

WidthThe "functions" (or methods in .NET) would be:

Area (= Length*Width)
Perimeter (= 2*Length + 2*Width)Methods vary from Properties because they require some transformation of data to achieve a result. Methods can either return a result (such as Area) or not. Like above with the chair, if you Sit() on the chair, there is no expected reaction, the chair just ... works! 

=== System.Object ===
To support the first rule of OOP - Inheritance, we define something that all objects will derive from - this is System.Object, also known as Object or object. This object defines some methods that all objects can use should they need to. These methods include:

GetHashCode() - retrieve a number unique to that object.
GetType() - retrieves information about the object like method names, the objects name etc.
ToString() - convert the object to a textual representation - usually for outputting to the screen or file.Since all objects derive from this class (whether you define it or not), any class will have these three methods ready to use. Since we always inherit from System.Object, or a class that itself inherits from System.Object, we therefore enhance and/or extend its functionality. Like in the real world that humans, cats, dogs, birds, fish are all an improved and specialised version of an "organism".

== Object basics ==
All objects by default are reference types. To support value types, objects must instead inherit from the System.ValueType abstract class, rather than System.Object.

=== Constructors ===
When objects are created, they are initialized by the "constructor". The constructor sets up the object, ready for use. Because objects need to be created before being used, the constructor is created implicitly, unless it is defined differently by the developer. There are 3 types of constructor:

Copy Constructor
Static Constructor
Default constructor - takes no parameters.
Overloaded constructor - takes parameters.Overloaded constructors automatically remove the implicit default constructor, so a developer must explicitly define the default constructor, if they want to use it.
A constructor is a special type of method in C# that allows an object to initialize itself when it is created. If a constructor method is used, there is no need to write a separate method to assign initial values to the data members of an object.
Important characteristics of a constructor method:

A constructor method has the same name as the class itself.
A constructor method is usually declared as public.
Constructor method is declared as public because it is used to create objects from outside the class in which it is declared. We can also declare a constructor method as private, but then such a constructor cannot be used to create objects.
Constructor methods do not have a return type (not even void).
C# provides a default constructor to every class. This default constructor initializes the data members to zero. But if we write our own constructor method, then the default constructor is not used.
A constructor method is used to assign initial values to the member variables.
The constructor is called by the new keyword when an object is created.
We can define more than one constructor in a class. This is known as constructor overloading. All the constructor methods have the same name, but their signatures are different, i.e., number and type of parameters are different.
If a constructor is declared, no default constructor is generated.

==== Copy Constructor ====
A copy constructor creates an object by copying variables from another object. The copy constructor is called by creating an object of the required type and passing it the object to be copied.
In the following example, we pass a Rectangle object to the Rectangle constructor so that the new object has the same values as the old object.

==== Static Constructor ====
A static constructor is first called when the runtime first accesses the class. Static variables are accessible at all times, so the runtime must initialize it on its first access.
The example below, when stepping through in a debugger, will show that static MyClass() is only accessed when the MyClass.Number variable is accessed.
C# supports two types of constructors: static constructor and instance constructor. Whereas an instance constructor is called every time an object of that class is created, the static constructor is called only once. A static constructor is called before any object of the class is created, and is usually used to initialize any static data members of a class.
A static constructor is declared by using the keyword static in the constructor definition.  This constructor cannot have any parameters or access modifiers. In addition, a class can only have one static constructor. 
For example:

==== Default Constructor ====
The default constructor takes no parameters and is implicitly defined, if no other constructors exist. The code sample below show the before, and after result of creating a class.

==== Overloaded Constructors ====
To initialize objects in various forms, the constructors allow customization of the object by passing in parameters.

==== Calling other constructors ====
To minimise code, if another constructor implements the functionality better, you can instruct the constructor to call an overloaded (or default) constructor with specific parameters.

Base classes constructors can also be called instead of constructors in the current instance

=== Destructors ===
As well as being "constructed", objects can also perform cleanup when they are cleared up by the garbage collector. As with constructors, the destructor also uses the same name as the class, but is preceded by the tilde (~) sign. However, the garbage collector only runs when either directly invoked, or has reason to reclaim memory, therefore the destructor may not get the chance to clean up resources for a long time. In this case, look into use of the Dispose() method, from the IDisposable interface.
Destructors are recognised via the use of the ~ symbol in front of a constructor with no access modifier. For example:

Encapsulation is depriving the user of a class of information the user does not need, and preventing the user from manipulating objects in ways not intended by the designer.
A class element having public protection level is accessible to all code anywhere in the program. These methods and properties represent the operations allowed on the class to outside users.
Methods, data members (and other elements) with private protection level represent the internal state of the class (for variables), and operations that are not allowed to outside users. The private protection level is default for all class and struct members. This means that if you do not specify the protection modifier of a method or variable, it is considered as private by the compiler.
For example:

In this example, the public method the Frog class exposes are JumpLow and JumpHigh. Internally, they are implemented using the private Jump function that can jump to any height. This operation is not visible to an outside user, so they cannot make the frog jump 100 meters, only 10 or 1. The Jump private method is implemented by changing the value of a private data member _height, which is also not visible to an outside user. Some private data members are made visible by Properties.

== Protection Levels ==

=== Private ===
Private members are only accessible within the class itself. A method in another class, even a class derived from the class with private members cannot access the members. If no protection level is specified, class members will default to private.

=== Protected ===
Protected members can be accessed by the class itself and by any class derived from that class.

=== Public ===
Public members can be accessed by any method in any class. 

It is good programming practice not to expose member variables to the outside, unless it is necessary. This is true especially for fields that should only be accessible over accessor and mutator methods (getters and setters). Exceptions are member variables that are constant.

=== Internal ===
Internal members are accessible only in the same assembly and invisible outside it. If no protection level is specified for top level classes, they are treated as internal, and can only be accessed within the assembly.

=== Protected Internal ===
Protected internal members are accessible from any class derived from that class, or any class within the same assembly. So, it means protected or internal.Here, an example:

== References ==

= Advanced Concepts =

== Explanation By Analogy ==
What is the benefit of inheritance?

It saves you a lot of typing
It saves you from repeating yourself.Inheritance explained by analogy
Suppose you want to create an Eagle, a Falcon and a vulture. In order to create these flying creatures you notice that each of these creatures:

EatLet us assume for the sake of argument that all three types of birds: fly, breed and eat in exactly the same way. 
Without inheritance, you would be forced to copy code. i.e. the same code which causes an eagle to fly would also be copied to make the vulture fly. And it is axiomatic to programmers - who are a lazy bunch, not wanting to repeat themselves - that repetition is almost always a bad thing.
Note the eagle, falcon and vultures are all in fact birds. Accordingly, you could say that a bird, generally speaking, always has the characteristics of eating, breeding and flying. So using "inheritance" you could create generic 'bird' prototype, which eats, breeds and flies, and then once that is defined, you can have all other specific breeds of birds inherit those characteristics. In other words, using the prototype, you can design other specific birds off that prototyped design.
This means that the falcon automatically knows how to fly because it inherits that behaviour from the general Bird class. You basically don't have to repeat yourself.

== Inheritance ==
Inheritance is the ability to create a class from another class, the "parent" class, extending the functionality and state of the parent in the derived, or "child" class. It allows derived classes to overload methods from their parent class.
Inheritance is one of the pillars of object-orientation. It is the mechanism of designing one class from another and is one of the ideas for code reusability, supporting the concept of hierarchical classification. C# programs consist of classes, where new classes can either be created from scratch or by using some or all properties of an existing class.
Another feature related to inheritance and reusability of code is polymorphism, which permits the same method name to be used for different operations on different data types. Thus, C# supports code reusability by both features.
Important characteristics of inheritance include:

A derived class extends its base class. That is, it contains the methods and data of its parent class, and it can also contain its own data members and methods.
The derived class cannot change the definition of an inherited member.
Constructors and destructors are not inherited. All other members of the base class are inherited.
The accessibility of a member in the derived class depends upon its declared accessibility in the base class.
A derived class can override an inherited member.An example of inheritance:

== Subtyping Inheritance ==
The code sample below shows two classes, Employee and Executive.
Employee has the methods GetPayCheck and Work.
We want the Executive class to have the same methods, but differently implemented and one extra method, AdministerEmployee.
Below is the creation of the first class to be derived from.

Now, we create an Executive class that will override the GetPayCheck method:

You'll notice that there is no Work method in the Executive class, as it is inherited from Employee.

== Virtual Methods ==
If a base class contains a virtual method that it calls elsewhere and a derived class overrides that virtual method, the base class will actually call the derived class' method:

== Constructors ==
A derived class does not automatically inherit the base class' constructors, and it cannot be instantiated unless it provides its own. A derived class must call one of its base class' constructors by using the base keyword:

== Inheritance keywords ==
The way C# inherits from another class syntactically is by using the : operator.

To indicate a method that can be overridden, you mark the method with virtual.

To override a method, use the override keyword:

A missing new or override keyword for a derived method may result in errors or warnings during compilation.: Here an example:

The Square class method Area() will result in a compilation error, if it is derived from the ShapesA class:

error CS0534: 'ConsoleApplication3.Square' does not implement inherited abstract member

The same method will result in a compilation warning, if derived from the normal Shapes class:

warning CS0114: 'ConsoleApplication3.Square.Area()' hides inherited member 'ConsoleApplication3.Shapes.Area()'.
To make the current member override that implementation, add the override keyword. Otherwise add the new

== References ==

An INTERFACE in C# is a type definition similar to a class, except that it purely represents a contract 
between an object and its user. It can neither be directly instantiated as an object, nor can data members be defined. So, an interface is nothing but a collection of method and property declarations. The following defines a simple interface:

A CONVENTION             used in the .NET Framework (and likewise by many C# programmers) is to place an "I" at the beginning of an interface name to distinguish it from a class name. Another common  interface naming convention is used when an interface declares only one key method, such as Draw() in the above example. The interface name is then formed as an adjective by adding the "...able" suffix. So, the interface name above could also be IDrawable. This convention is used throughout the .NET Framework.
Implementing an interface is simply done by inheriting off it and defining all the methods and properties declared by the interface after that. For instance,

Although a class can inherit from one class only, it can inherit from any number of interfaces. This is a simplified form of multiple inheritance supported by C#. When inheriting from a class and one or more interfaces, the base class should be provided first in the inheritance list, followed by any interfaces to be implemented. For example:

Object references can be declared using an interface type. For instance, using the previous examples,

Interfaces can inherit off of any number of other interfaces, but cannot inherit from classes. For example:

== Additional details ==
Access specifiers (i.e. private, internal, etc.) cannot be provided for interface members, as all members are public by default. A class implementing an interface must define all the members declared by the interface. The implementing class has the option of making an implemented method virtual, if it is expected to be overridden in a child class.
There are no static methods within an interface, but any static methods can be implemented in a class that manages objects using it.
In addition to methods and properties, interfaces can declare events and indexers as well.
For those familiar with Java, C#'s interfaces are extremely similar to Java's.

== Introduction ==
Delegates and events are fundamental to any Windows or Web Application, allowing the developer to "subscribe" to particular actions carried out by the user. Therefore, instead of expecting everything and filtering out what you want, you choose what you want to be notified of and react to that action.
A delegate is a way of telling C# which method to call when an event is triggered. For example, if you click a Button on a form, the program would call a specific method. It is this pointer that is a delegate. Delegates are good, as you can notify several methods that an event has occurred, if you wish so.
An event is a notification by the .NET framework that an action has occurred. Each event contains information about the specific event, e.g., a mouse click would say which mouse button was clicked where on the form.
Let's say you write a program reacting only to a Button click. Here is the sequence of events that occurs:

User presses the mouse button down over a button
The .NET framework raises a MouseDown event
User releases the mouse button
The .NET framework raises a MouseUp event
The .NET framework raises a MouseClick event
The .NET framework raises a Clicked event on the ButtonSince the button's click event has been subscribed, the rest of the events are ignored by the program and your delegate tells the .NET framework which method to call, now that the event has been raised.

== Delegates ==
Delegates form the basis of event handling in C#. They are a construct for abstracting and creating objects that reference methods and can be used to call those methods. A delegate declaration specifies a particular method signature. References to one or more methods can be added to a delegate instance. The delegate instance can then be "called", which effectively calls all the methods that have been added to the delegate instance. A simple example:

In this example, the delegate is declared by the line delegate voidProcedure(). This statement is a complete abstraction. It does not result in executable code that does any work, but merely declares a delegate type called Procedure that takes no arguments and returns nothing. Next, in the Main() method, the statement Procedure someProcs = null; instantiates a delegate. The assignment means that the delegate is not initially referencing any methods. The statements someProcs += newProcedure(DelegateDemo.Method1) and
someProcs += newProcedure(Method2) add two static methods to the delegate instance. Note that the class name can also be left off, as the statement is occurring inside DelegateDemo. The statement someProcs += newProcedure(demo.Method3) adds a non-static method to the delegate instance. For a non-static method, the method name is preceded by an object reference. When the delegate instance is called, Method3() is called on the object that was supplied when the method was added to the delegate instance. Finally, the statement someProcs() calls the delegate instance. All the methods that were added to the delegate instance are now called in the order that they were added.
Methods that have been added to a delegate instance can be removed with the -= operator:

In C# 2.0, adding or removing a method reference to a delegate instance can be shortened as follows:

Invoking a delegate instance that presently contains no method references results in a NullReferenceException.
Note that, if a delegate declaration specifies a return type and multiple methods are added to a delegate instance, an invocation of the delegate instance returns the return value of the last method referenced. The return values of the other methods cannot be retrieved (unless explicitly stored somewhere in addition to being returned).

== Anonymous delegates ==
Anonymous delegates are a short way to write delegate code, specified using the delegate keyword. The delegate code can also reference local variables of the function in which they are declared. Anonymous delegates are automatically converted into methods by the compiler. For example:

They can accept arguments just as normal methods can:

The output is:

testing, 100

=== Lambda expressions ===
Lambda expressions are a clearer way to achieve the same thing as an anonymous delegate. Its form is:

(type1 arg1, type2 arg2, ...) => expression

This is equivalent to:

If there is only one argument, the parentheses can be omitted. The type names can also be omitted to let the compiler infer the types from the context. In the following example, str is a string, and the return type is an int:

This is equivalent to:

== Events ==
An event is a special kind of delegate that facilitates event-driven programming. Events are class members that cannot be called outside of the class regardless of its access specifier. So, for example, an event declared to be public would allow other classes the use of += and -= on the event, but firing the event (i.e. invoking the delegate) is only allowed in the class containing the event. A simple example:

A method in another class can then subscribe to the event by adding one of its methods to the event delegate:

Even though the event is declared public, it cannot be directly fired anywhere except in the class containing it.

In general terms, an interface is the set of public members of a component. Of course, this is also true for C# interface. A C# class also defines an interface, as it has a set of public members. A non-abstract C# class defines the implementation of each member.
In C#, it is possible to have a type that is intermediate between a pure interface that does not define any implementation, and a type that defines a complete implementation. This is called an abstract class and is defined by including the abstract keyword in the class definition.
An abstract class is somewhere between a C# interface and a non-abstract class. Of the public members defined by an abstract class, any number of those members may include an implementation.
For example, an abstract class might provide an implementation for none of its members.

This class is equivalent to an interface in many respects. (One difference is
that a class that derives from this class cannot derive from any other class.)
An abstract class may also define all of its members.

And an abstract class may define some of its members, but leave others undefined.

Although an abstract class is similar to a non-abstract class, some important differences exist. For one thing, you cannot create an instance of an abstract class with the new keyword. For example, the following statement will raise a compiler error:

Of course, assuming the concrete class Square derives from AbstractShape, the following would be correct:

A second difference is that an abstract class may have abstract members. As was shown above, this is not a must. To create a class with at least one abstract member, the abstract keyword must be added before the class keyword.
The third difference is that a class cannot be both abstract and sealed.

== Implementing methods ==
As with virtual methods, you can implement abstract methods or properties with the override keyword:

Overriding an abstract method is effectively the same as overriding a virtual method - you cannot change the access specifiers (i.e. you can't convert a protected abstract method into public), and you cannot add a missing get or set to an abstract property. The only difference is that "forgetting" the new or override keyword results in an error, if the class this method is belonging to was derived from an abstract class, and it will result in a warning, if the class tries to override a virtual method.

== Partial Classes ==
As the name indicates, partial class definitions can be split up across multiple physical files. To the compiler, this does not make a difference, as all the fragments of the partial class are grouped and the compiler treats it as a single class. One common usage of partial classes is the separation of automatically-generated code from programmer-written code.
Below is an example of a partial class.
Listing 1: Entire class definition in one file (file1.cs)

Listing 2: Class split across multiple files


Generics are a new feature available since version 2.0 of the C# language and the common language runtime (CLR). Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code. The most common use of generics is to create collection classes. Generic types were introduced to maximize code reuse, type safety, and performance.

== Generic classes ==
There are cases when you need to create a class to manage objects of some type, without modifying them. Without generics, the usual approach (highly simplified) to make such class would be like this:

And its usage would be:

Note that we have to cast back to original data type we have chosen (in this case - int) every time we want to get an object from such a container. In such small programs like this, everything is clear. But in more complicated cases with more containers in different parts of the program, we would have to take care that the container is supposed to have int type in it and no other data type, as in such a case, a InvalidCastException is thrown.
Additionally, if the original data type we have chosen is a value type, such as int, we will incur a performance penalty every time we access the elements of the collection due to the autoboxing feature of C#.
However, we could surround every unsafe area with a try - catch block, or we could create a separate "container" for every data type we need just to avoid casting. While both ways could work (and worked for many years), it is unnecessary now, because generics offers a much more elegant solution.
To make our "container" class to support any object and avoid casting, we replace every previous object type with some new name, in this case T, and add  mark immediately after the class name to indicate that this T type is generic/any type.

Note: You can choose any name and use more than one generic type for class, i.e .
Not a big difference, which results in simple and safe usage:

Generics ensures that you specify the type for a "container" once, avoiding previously mentioned problems and autoboxing for structs.
While this example is far from practical, it does illustrate some situations where generics are useful:

You need to keep objects of a single type in a class
You do not need to modify objects
You need to manipulate objects in some way
You wish to store a "value type" (such as int, short, string, or any custom struct) in a collection class without incurring the performance penalty of autoboxing every time you manipulate the stored elements.

== Generic interfaces ==
A generic interface accepts one or more type parameters, similar to a generic class:

Generic interfaces are useful when multiple implementations of a particular class are possible. For example, both the List class (discussed below) and the LinkedList class, both from the System.Collections.Generic namespace, implement the IEnumerable interface. List has a constructor that creates a new list based on an existing object that implements IEnumerable, and so we can write the following:

== Generic methods ==
Generic methods are very similar to generic classes and interfaces:

This method can be used to search any type of array:

== Type constraints ==
One may specify one or more type constraints in any generic class, interface or method using the where keyword. The following example shows all of the possible type constraints:

These type constraints are often necessary to

create a new instance of a generic type (the new()) constraint
use foreach on a variable of a generic type (the IEnumerable constraint)
use using on a variable of a generic type (the IDisposable constraint)

== Notes ==

Extension methods are a feature new to C# 3.0 and allow you to extend existing types with your own methods. While they are static, they are used as if they are normal methods of the class being extended. Thus, new functionality can be added to an existing class without a need to change or recompile the class itself. However, since they are not directly part of the class, extensions cannot access private or protected methods, properties, or fields. 
Extension methods should be created inside a static class. They themselves should be static and should contain at least one parameter, the first preceded by the this keyword:

The type of the first parameter (in this case List) specifies the type with which the extension method will be available. You can now call the extension method like this:

Here is the rest of the program:

Note that extension methods can take parameters simply by defining more than one parameter without the this keyword.

== Introduction ==
All computer programs use up memory, whether that is a variable in memory, opening a file or connecting to a database. The question is how can the runtime environment reclaim any memory when it is not being used? There are three answers to this question:

If you are using a managed resource, this is automatically released by the Garbage Collector
If you are using an unmanaged resource, you must use the IDisposable interface to assist with the cleanup
If you are calling the Garbage Collector directly, by using System.GC.Collect() method, it will be forced to tidy up resources immediately.Before discussing managed and unmanaged resources, it would be interesting to know what the garbage collector actually does.

=== Garbage Collector ===
The garbage collector is a background process running within your program. It is always present within all .NET applications. Its job is to look for objects (i.e. reference types) which are no longer being used by your program. If the object is assigned to null, or the object goes out of scope, the garbage collector will mark the object be cleaned up at some point in the future, and not necessarily have its resources released immediately! 
Why? The garbage collector will have a hard time keeping up with every de-allocation you make, especially at the speed the program runs and therefore only runs when resources become limited. Therefore, the garbage collector has three "generations".

Generation 0 - the most recently created objects
Generation 1 - the mid-life objects
Generation 2 - the long term objects.All reference types will exist in one of these three generations. They will firstly be allocated to Gen 0, then moved to Gen 1 and Gen 2 depending on their lifetime. The garbage collector works by removing only what is needed and so will only scan Gen 0 for a quick-fix solution. This is because most, if not all, local variables are placed in this area.
For more in-depth information, visit the MSDN Article for a better explanation. 
Now you know about the garbage collector, let's discuss the resources that it is managing.

=== Managed Resources ===
Managed resources are objects which run totally within the .NET framework. All memory is reclaimed for you automatically, all resources closed and you are in most cases guaranteed to have all the memory released after the application closes, or when the garbage collector runs.
You do not have to do anything with them with regards to closing connections or anything, it is a self-tidying object.

=== Unmanaged Resources ===
There are circumstances where the .NET framework world will not release resources. This may be because the object references resources outside of the .NET framework, like the operating system, or internally references another unmanaged component, or that the resources accesses a component that uses COM, COM+ or DCOM. 
Whatever the reason, if you are using an object that implements the IDisposable interface at a class level, then you too need to implement the IDisposable interface too. 

This interface exposes a method called Dispose(). This alone will not help tidy up resources, as it is only an interface, so the developer must use it correctly in order to ensure the resources are released. The two steps are:

Always call Dispose() on any object that implements IDisposable as soon as you are finished using it. (This can be made easier with the using keyword)
Use the finalizer method to call Dispose(), so that if anyone has not closed your resources, your code will do it for them.

==== Dispose pattern ====
Often, what you want to clean up varies depending on whether your object is being finalized. For example, you would not want to clean up managed resources in a finalizer since the managed resources could have been reclaimed by the garbage collector already. The dispose pattern can help you implement resource management properly in this situation:

=== Applications ===
If you are coming to C# from Visual Basic Classic you will have seen code like this:

Note that neither oFSO nor oFile are explicitly disposed of. In Visual Basic Classic this is not necessary because both objects are declared locally. This means that the reference count goes to zero as soon as the function ends which results in calls to the Terminate event handlers of both objects. Those event handlers close the file and release the associated resources.
In C# this doesn't happen because the objects are not reference counted. The finalizers will not be called until the garbage collector decides to dispose of the objects. If the program uses very little memory this could be a long time. 
This causes a problem because the file is held open which might prevent other processes from accessing it.
In many languages the solution is to explicitly close the file and dispose of the objects and many C# programmers do just that. However, there is a better way: use the using statement:

Behind the scenes the compiler turns the using statement into
try ... finally and produces this intermediate language (IL) code:

Notice that the body of the Read function has been split into
three parts: initialisation, try, and finally. The finally block
includes code that was never explicitly specified in the original C#
source code, namely a call to the destructor of the
Streamreader instance.
See Understanding the 'using' statement in C# By TiNgZ aBrAhAm.
See the following sections for more applications of this technique.

=== Resource Acquisition Is Initialisation ===
The application of the using statement in the introduction is an example of an idiom called Resource Acquisition Is Initialisation (RAII).
RAII is a natural technique in languages like Visual Basic Classic and C++ that have deterministic finalization, but usually requires extra work to include in programs written in garbage collected languages like C# and VB.NET. The using statement makes it just as easy. Of course you could write the try..finally code out explicitly and in some cases that will still be necessary. For a thorough discussion of the RAII technique see HackCraft: The RAII Programming Idiom. Wikipedia has a brief note on the subject as well: Resource Acquisition Is Initialization.
Work in progress:  add C# versions showing incorrect and correct methods with and without using. Add notes on RAII, memoization and cacheing (see OOP wikibook).
Design Patterns are common building blocks designed to solve everyday software issues.
Some basic terms and example of such patterns include what we see in everyday life.
Key patterns are the singleton pattern, the factory pattern, and chain of responsibility patterns.

== Factory Pattern ==
The factory pattern is a method call that uses abstract classes and its implementations, to give the developer the most appropriate class for the job.
Lets create a couple of classes first to demonstrate how this can be used. Here we take the example of a bank system.

This Transaction class is incomplete, as there are many types of transactions:

ClosureFor this example, we will take credit and withdrawal portions, and create classes for them.

The problem is that these classes do much of the same thing, so it would be helpful, if we could just give it the values, and it will work out what class type we require. Therefore, we could come up with some ways to distinguish between the different types of transactions:

Positive values indicate a credit.
Negative values indicate a withdrawal.
Having two account numbers and a positive value would indicate a transfer.
Having two account numbers and a negative value would indicate a closure.
etc.So, let us write a new class with a static method that will do this logic for us, ending the name Factory:

Now, you can use this class to do all of the logic and processing, and be assured that the type you are returned is correct.

== Singleton ==
The singleton pattern instantiates only 1 object, and reuses this object for the entire lifetime of the process. This is useful, if you wish the object to maintain state, or if it takes lots of resources to set the object up. Below is a basic implementation:

The Singleton property will expose the same instance to all callers. Upon the first call, the object is initialised and on subsequent calls this is used.
Examples of this pattern include:

ConfigurationSettings (Generic settings reader)
HttpApplication (Application object in ASP .NET)
HttpCacheUtility (Cache object in ASP .NET)
HttpServerUtility (Server object in ASP .NET)

= The .NET Framework =
.NET Framework is a common environment for building, deploying, and running Web Services, Web Applications, Windows Services and Windows Applications. The .NET Framework contains common class libraries - like ADO.NET, ASP.NET and Windows Forms - to provide advanced standard services that can be integrated into a variety of computer systems.

== Introduction ==
In June 2000 Microsoft  released both the .NET platform and a new program language called C#. C# is a general-purpose OOP language designed to give optimum simplicity, expansiveness, and performance. Its syntax is very similar to Java, with the major difference being that all variable types are derived from a common ancestor class.
C# is a language in itself. It can perform mathematical and logical operations, variable assignment and other expected traits of a programming language. This in itself is not flexible enough for more complex applications. At some stage, the developer will want to interact with the host system whether it be reading files or downloading content from the Internet.
The .NET framework is a toolset developed for the Windows platform to allow the developer to interact with the host system or any external entity whether it be another process, or another computer. The .NET platform is a Windows platform-specific implementation. Other operating systems have their own implementations due to the differences in the operating systems I/O management, security models and interfaces.

== Background ==
Originally called NGWS (Next Generation Windows Services).
.NET does not run in any browser. It is a runtime language (Common Language Runtime) like the Java runtime. By contrast, Microsoft Silverlight does run in a browser.
.NET is based on the newest Web standards.
.NET is built on the following Internet standards:
HTTP, the communication protocol between Internet Applications
SOAP, the standard format for requesting Web Services
UDDI, the standard to search and discover Web Services
XML, the format for exchanging data between Internet Applications

== Console Programming ==

=== Input ===
Input can be gathered in a similar method to outputing data using the Read() and ReadLine methods of that same System.Console class:

The above program requests the user's name and displays it back. The final Console.ReadKey() waits for the user to enter a key before exiting the program.

=== Output ===
The example program below shows a couple of ways to output text:

The above code displays the following text:

Hello World!
This is... my first program!
Goodbye World!

That text is output using the System.Console class. The using statement at the top allows the compiler to find the Console class without specifying the System namespace each time it is used.
The middle lines use the Write() method, which does not automatically create a new line. To specify a new line, we can use the sequence backslash-n (\n). If for whatever reason we wanted to really show the \n character instead, we add a second backslash (\\n). The backslash is known as the escape character in C# because it is not treated as a normal character, but allows us to encode certain special characters (like a new line character).

=== Error ===
The Error output is used to divert error specific messages to the console. To a novice user this may seem fairly pointless, as this achieves the same as Output (as above). If you decide to write an application that runs another application (for example a scheduler), you may wish to monitor the output of that program - more specifically, you may only wish to be notified only of the errors that occur. If you coded your program to write to the Console.Error stream whenever an error occurred, you can tell your scheduler program to monitor this stream, and feedback any information that is sent to it. Instead of the Console appearing with the Error messages, your program may wish to log these to a file.
You may wish to revisit this after studying Streams and after learning about the Process class.

=== Command line arguments ===
Command line arguments are values that are passed to a console program before execution. For example, the Windows command prompt includes a copy command that takes two command line arguments. The first argument is the original file and the second is the location or name for the new copy. Custom console applications can have arguments as well.
c sharp is object based programming language.
.net framework is a Microsoft programming language is used to create web application,console application, mobile application.

If the above code is compiled to a program called username.exe, it can be executed from the command line using two arguments, e.g. "Bill" and "Gates":

C:\>username.exe Bill Gates

Notice how the Main() method above has a string array parameter. The program assumes that there will be two arguments. That assumption makes the program unsafe. If it is run without the expected number of command line arguments, it will crash when it attempts to access the missing argument. To make the program more robust, we can check to see if the user entered all the required arguments.

Try running the program with only entering your first name or no name at all. The args.Length property returns the total number of arguments. If no arguments are given, it will return zero.
You are also able to group a single argument together by using the quote marks (""). This is particularly useful if you are expecting many parameters, but there is a requirement for including spaces (e.g. file locations, file names, full names etc.)

C:\> Test.exe Separate words "grouped together"
1: Separate
2: words
3: grouped together

=== Formatted output ===
Console.Write() and Console.WriteLine() allow you to output a text string, but also allows writing a string with variable substitution. 
These two functions normally have a string as the first parameter. When additional objects are added, either as parameters or as an array, the function will scan the string to substitute objects in place of tokens.
For example:

The {0} is identified by braces, and refers to the parameter index that needs to be substituted. You may also find a format specifier within the braces, which is preceded by a colon and the specifier in the question (e.g. {0:G}).

=== Rounding number example ===
This is a small example that rounds a number to a string. It is an augmentation for the Math class of C#. The result of the Round method has to be rounded to a string, as significant figures may be trailing zeros that would disappear, if a number format would be used. Here is the code and its call. You are invited to write a shorter version that gives the same result, or to correct errors!
The constant class contains repeating constants that should exist only once in the code so that to avoid inadvertant changes. (If the one constant is changed inadvertantly, it is most likely to be seen, as it is used at several locations.)

The Math class is an enhancement to the  library and contains the rounding calculations.

Extensive testing of a software is crucial for qualitative code. To say that the code is tested does not give much information. The question is what is tested. Not in this case, but often it is also important to know where (in which environment) it was tested, and how - i.e. the test succession. Here is the code used to test the Maths class.

The results of your better code should comply with the result I got:

Maths.Round('.', 0, 5) = 0.00000
Maths.Round('.', -1.40129846432482E-45, 5) = -1.4012E-45
Maths.Round('.', 1.40129846432482E-45, 5) = 1.4013E-45
Maths.Round('.', -1.999999757E-05, 5) = -1.9999E-5
Maths.Round('.', 1.999999757E-05, 5) = 2.0000E-5
Maths.Round('.', -0.0001999999757, 5) = -0.00019999
Maths.Round('.', 0.0001999999757, 5) = 0.00020000
Maths.Round('.', -0.001999999757, 5) = -0.0019999
Maths.Round('.', 0.001999999757, 5) = 0.0020000
Maths.Round('.', -0.000640589, 5) = -0.00064058
Maths.Round('.', 0.000640589, 5) = 0.00064059
Maths.Round('.', -0.339689999818802, 5) = -0.33968
Maths.Round('.', 0.339689999818802, 5) = 0.33969
Maths.Round('.', -0.34, 5) = -0.33999
Maths.Round('.', 0.34, 5) = 0.34000
Maths.Round('.', -7.07, 5) = -7.0699
Maths.Round('.', 7.07, 5) = 7.0700
Maths.Round('.', -118.188, 5) = -118.18
Maths.Round('.', 118.188, 5) = 118.19
Maths.Round('.', -118.2, 5) = -118.19
Maths.Round('.', 118.2, 5) = 118.20
Maths.Round('.', -123.405009, 5) = -123.40
Maths.Round('.', 123.405009, 5) = 123.41
Maths.Round('.', -30.7699432373047, 5) = -30.769
Maths.Round('.', 30.7699432373047, 5) = 30.770
Maths.Round('.', -130.769943237305, 5) = -130.76
Maths.Round('.', 130.769943237305, 5) = 130.77
Maths.Round('.', -540, 5) = -539.99
Maths.Round('.', 540, 5) = 540.00
Maths.Round('.', -12345, 5) = -12344
Maths.Round('.', 12345, 5) = 12345
Maths.Round('.', -123456, 5) = -123450
Maths.Round('.', 123456, 5) = 123460
Maths.Round('.', -540911, 5) = -540900
Maths.Round('.', 540911, 5) = 540910
Maths.Round('.', -9.22337203685478E+56, 5) = -9.2233E56
Maths.Round('.', 9.22337203685478E+56, 5) = 9.2234E56

If you are interested in a comparison with C++, please compare it with the same example there. If you want to compare C# with Java, take a look at the rounding number example there.

== System.Windows.Forms ==
To create a Windows desktop application we use the library represented by System.Windows.Forms namespace. Some commonly used classes in this namespace include:

Control - generic class from which other useful classes, like Form, TextBox and others listed below are derived
Form - this is the base class for the program window. All other controls are placed directly onto a Form or indirectly on another container (like TabPage or TabControl) that ultimately resides on the Form. When automatically created in Visual Studio, it is usually subclassed as Form1.
Button - a clickable button
TextBox - a singleline or multiline textbox that can be used for displaying or inputting text
RichTextBox - an extended TextBox that can display styled text, e.g. with parts of the text colored or with a specified font. RichTextBox can also display generalized RTF document, including embedded images.
Label - simple control allowing display of a single line of unstyled text, often used for various captions and titles
ListBox - control displaying multiple items (lines of text) with ability to select an item and to scroll through it
ComboBox - similar to ListBox, but resembling a dropdown menu
TabControl and TabPage - used to group controls in a tabbed interface (much like tabbed interface in Visual Studio or Mozilla Firefox). A TabControl contains a collection of TabPage objects.
DataGrid - data grid/table view

== Form class ==
The Form class (System.Windows.Forms.Form) is a particularly important part of that namespace because the form is the key graphical building block of Windows applications. It provides the visual frame that holds buttons, menus, icons, and title bars together. Integrated development environments (IDEs) like Visual C# and SharpDevelop can help create graphical applications, but it is important to know how to do so manually:

The example above creates a simple Window with the text "I Love Wikibooks" in the title bar. Custom form classes like the example above inherit from the System.Windows.Forms.Form class. Setting any of the properties Text, Width, and Height is optional. Your program will compile and run successfully, if you comment these lines out, but they allow us to add extra control to our form.

== Events ==
An event is an action being taken by the program when a user or the computer makes an action (for example, a button is clicked, a mouse rolls over an image, etc.). An event handler is an object that determines what action should be taken when an event is triggered.

== Controls ==

The Windows Forms namespace has a lot of very interesting classes. One of the simplest and important is the Form class. A form is the key building block of any Windows application. It provides the visual frame that holds buttons, menus, icons and title bars together. Forms can be modal and modalless, owners and owned, parents and children. While forms could be created with a notepad, using a form editor like VS.NET, C# Builder or Sharp Develop makes development much faster. In this lesson, we will not be using an IDE. Instead, save the code below into a text file and compile with command line compiler.

== Lists ==
A list is a dynamic array that resizes itself as needed, if more data is inserted than it can hold at the time of insertion. Items can be inserted at any index, deleted at any index and accessed at any index. The C# non-generic list class is the ArrayList, while the generic one is List.
Many of the List class' methods and properties are demonstrated in the following example:

The terminal output is:

List demo
| bread | butter | chocolate | roast beef | tomato | vanilla cake | yoghurt |
The list now has 0 items.

== LinkedLists ==
Items in a linked list can be accessed directly only one after the other. Of course an item at any index can be accessed, but the list must iterate to the item from the first one, which is much slower than accessing items by index in an array or a list. There is no non-generic linked list in C#, while the generic one is LinkedList.

== Queues ==
A queue is a FIFO (first in - first out) collection. The item first pushed in the queue gets taken first with the pop function. Only the first item is accessible at any time, and items can only be put to the end. The non-generic queue class is called Queue, while the generic one is Queue.

== Stacks ==
A stack is a LIFO (last in - first out) collection. The item pushed in first will be the last to be taken by pop. Only the last item is accessible at any time, and items can only be put at the top. The non-generic stack class is Stack, while the generic one is Stack.

== Hashtables and dictionaries ==
A dictionary is a collection of values with keys. The values can be very complex, yet searching the keys is still fast. The non-generic class is Hashtable, while the generic one is Dictionary.

Threads are tasks that can run concurrently to other threads and can share data. When your program starts, it creates a thread for the entry point of your program, usually a Main function. So, you can think of a "program" as being made up of threads. The .NET Framework allows you to use threading in your programs to run code in parallel to each other. This is often done for two reasons:

If the thread running your graphical user interface performs time-consuming work, your program may appear to be unresponsive. Using threading, you can create a new thread to perform tasks and report its progress to the GUI thread.
On computers with more than one CPU or CPUs with more than one core, threads can maximize the use of computational resources, speeding up tasks.

== The Thread class ==
The System.Threading.Thread class exposes basic functionality for using threads. To create a thread, you simply create an instance of the Thread class with a ThreadStart or ParameterizedThreadStart delegate pointing to the code the thread should start running. For example:

You should see the following output:

First thread says hello.
Second thread says hello.
First thread says hello.
First thread says hello.
Second thread says hello.

Notice that the while keyword is needed because as soon as the function returns, the thread exits, or terminates.

=== ParameterizedThreadStart ===
The void ParameterizedThreadStart(object obj) delegate allows you to pass a parameter to the new thread:

The output is:

First thread says hello.
Second thread says 1234.
Second thread says 1234.
First thread says hello.

== Sharing Data ==
Although we could use ParameterizedThreadStart to pass parameter(s) to threads, it is not typesafe and is clumsy to use. We could exploit anonymous delegates to share data between threads, however:

Notice how the body of the anonymous delegate can access the local variable number.

== Asynchronous Delegates ==
Using anonymous delegates can lead to a lot of syntax, confusion of scope, and lack of encapsulation. However with the use of lambda expressions, some of these problems can be mitigated. Instead of anonymous delegates, you can use asynchronous delegates to pass and return data, all of which is type safe. It should be noted that when you use an asynchronous delegate, you are actually queuing a new thread to the thread pool. Also, using asynchronous delegates forces you to use the asynchronous model.

== Synchronization ==
In the sharing data example, you may have noticed that often, if not all of the time, you will get the following output:

First thread says 2.
Second thread says 3.
Second thread says 5.
First thread says 4.
Second thread says 7.
First thread says 7.

One would expect that at least, the numbers would be printed in ascending order! This problem arises because of the fact that the two pieces of code are running at the same time. For example, it printed 3, 5, then 4. Let us examine what may have occurred:

After "First thread says 2", the first thread incremented number, making it 3, and printed it.
The second thread then incremented number, making it 4.
Just before the second thread got a chance to print number, the first thread incremented number, making it 5, and printed it.
The second thread then printed what number was before the first thread incremented it, that is, 4. Note that this may have occurred due to console output buffering.The solution to this problem is to synchronize the two threads, making sure their code doesn't interleave like it did. C# supports this through the lock keyword. We can put blocks of code under this keyword:

The variable numberLock is needed because the lock keyword only operates on reference types, not value types. This time, you will get the correct output:

First thread says 2.
Second thread says 3.
Second thread says 4.
First thread says 5.
Second thread says 6.

The lock keyword operates by trying to gain an exclusive lock on the object passed to it (numberLock). It will only release the lock when the code block has finished execution (that is, after the }). If an object is already locked when another thread tries to gain a lock on the same object, the thread will block (suspend execution) until the lock is released, and then lock the object. This way, sections of code can be prevented from interleaving.

=== Thread.Join() ===
The Join method of the Thread class allows a thread to wait for another thread, optionally specifying a timeout:

The output is:

Just started second thread.
Second thread reporting.
First thread waited for 1 second.
Second thread done sleeping.
First thread finished waiting for second thread. Press any key.

The .NET Framework currently supports calling unmanaged functions and using unmanaged data, a process called marshalling. This is often done to use Windows API functions and data structures, but can also be used with custom libraries.

== GetSystemTimes ==
A simple example to start with is the Windows API function GetSystemTimes. It is declared as:

LPFILETIME is a pointer to a FILETIME structure, which is simply a 64-bit integer. Since C# supports 64-bit numbers through the long type, we can use that. We can then import and use the function as follows:

Note that the use of out or ref in parameters automatically makes it a pointer to the unmanaged function.

== GetProcessIoCounters ==
To pass pointers to structs, we can use the out or ref keyword:

= Keywords =

Abstract classes may contain abstract members in addition to implemented ones. That is, while some of the methods and properties in an abstract class may be implemented, others (the abstract members) may have their signatures defined, but have no implementation. Concrete subclasses derived from an abstract class define those methods and properties.

The as keyword casts an object to a different type. It is therefore similar to the TypeA varA = (TypeA) varB syntax. The difference is that this keyword returns null if the object was of an incompatible type, while the former method throws a type-cast exception in that case.

=== See also ===

The keyword base describes that you would like to refer to the base class for the requested information, not in the current instantiated class.
A base class is the class in which the currently implemented class inherits from. When creating a class with no defined base class, the compiler automatically uses the System.Object base class.
Therefore the two declarations below are equivalent.

Some of the reasons the base keyword is used is:

Passing information to the base class's constructor
Recalling variables in the base class, where the newly implemented class is overriding its behaviour
Recalling methods in the base class. This is useful when you want to add to a method, but still keep the underlying implementation.

The bool keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Boolean. That is, it represents a value of true or false. Unlike in C++, whose boolean is actually an integer, a bool in C# is its own data type and cannot be cast to any other primitive type.

The keyword break is used to exit out of a loop or switch block.

break as used in a loop

The while loop would increment x as long as it was less than twenty. However when x is incremented to ten the condition in the if statement becomes true, so the break statement causes the while loop to be broken and execution would continue after the closing parentheses.

break as used in a switch block

When the program enters the switch block, it will search for a case statement that is true. Once it finds one, it will read any further statements printed until it finds a break statement. In the above example, if x is 0 or 1, the console will only print their respective values and then jump out of the statement. However, if the value of x is 2 or 3, the program will read the same proceeding statement(s) until it reaches a break statement. In order not to show anybody who reads the code that this handling for 2 is the same for three, it is good programming practice to add a comment like "falls through" after the falling-through cases.

The byte keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Byte. That is, it represents an 8-bit unsigned integer whose value ranges from 0 to 255.

The keyword case is often used in a switch statement.

The keyword catch is used to identify a statement or statement block for execution, if an exception occurs in the body of the enclosing try block. The catch clause is preceded by the try clause, and may optionally be followed by a finally clause.

The char keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Char. That is, it represents a Unicode character whose from 0 to 65,535.

The checked and unchecked operators are used to control the overflow checking context for integral-type arithmetic operations and conversions. It checks, if there is an overflow (this is default).

See also[1]
The class keyword is used to declare a class.

The const keyword is used in field and local variable declarations to make the variable constant. It is thus associated with its declaring class or assembly instead of with an instance of the class or with a method call. It is syntactically invalid to assign a value to such a variable anywhere other than its declaration.

Further readingConstant function parameters

The keyword continue can be used inside any loop in a method. Its affect is to end the current loop iteration and proceed to the next one. If executed inside a for, end-of-loop statement is executed (just like normal loop termination).

The decimal keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Decimal. That is, it represents a signed, 128-bit decimal number whose value is 0 or a decimal number with 28 or 29 digits of precision ranging either from 
    {\displaystyle -1.0\times 10^{-28}}
    {\displaystyle -7.9\times 10^{28}}
   or from 
    {\displaystyle 1.0\times 10^{-28}}
    {\displaystyle 7.9\times 10^{28}}

The default keyword can be used in the switch statement or in generic code:
The switch statement: Specifies the default label.
Generic code: Specifies the default value of the type parameter. This will be null for reference types and zero for value types.

== References ==

The delegate keyword is used to declare a delegate. A delegate is a programming construct that is used to obtain a callable reference to a method of a class.

The do keyword identifies the beginning of a do ... loop.

The double keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Double. That is, it represents an IEEE 754, 64-bit signed binary floating point number whose value is negative 0, positive 0, negative infinity, positive infinity, not a number, or a number ranging either from 
    {\displaystyle -5.0\times 10^{-324}}
    {\displaystyle -1.79\times 10^{308}}
   or from 
    {\displaystyle 5.0\times 10^{-324}}
    {\displaystyle 1.79\times 10^{308}}

The else keyword identifies a else clause of an if statement with the following syntax:

if-statement ::= "if" "(" condition ")" if-body "else" else-body
condition ::= boolean-expression
if-body ::= statement-or-statement-block
else-body ::= statement-or-statement-blockAn else clause immediately follows an if-body. It provides code to execute when the condition is false. Making the else-body another if statement creates the common cascade of if, else if, else if, else if, else statements:

The above example only checks whether myNumber is less than 0, if myNumber is not 4. It in turn only checks whether myNumber%2 is 0, if myNumber is not less than 0. Since none of the conditions are true, it executes the body of the final else clause.

The enum keyword identifies an enumeration.

The event keyword is used to declare an event.	

=== General ===
When values are cast implicitly, the runtime does not need any casting in code by the developer in order for the value to be converted to its new type.
Here is an example, where the developer is casting explicitly:

The developer has told the runtime, "I know what I'm doing, force this conversion."
Implicit casting means that runtime doesn't need any prompting in order to do the conversion. Here is an example of this.

=== Keyword ===
Notice that no casting was necessary by the developer. What is special about implicit, is that the context that the type is converted to is totally lossless i.e. converting to this type loses no information, so it can be converted back without worry.
The explicit keyword is used to create type conversion operators that can only be used by specifying an explicit type cast.
This construct is useful to help software developers write more readable code. Having an explicit cast name makes it clear that a conversion is taking place.


The keyword extern indicates that the method being called exists in a DLL.
A tool called tlbimp.exe can create a wrapper assembly that allows C# to interact with the DLL like it was a .NET assembly i.e. use constructors to instantiate it, call its methods.
Older DLLs will not work with this method. Instead, you have to explicitally tell the compiler what DLL to call, what method to call and what parameters to pass. Since parameter type is very important, you can also explicitly define what type the parameter should be passed to the method as.
Here is an example:

The [DllImport("user32.dll")] tells the compiler which DLL to reference. Windows searches for files as defined by the PATH environment variable, and therefore will search those paths before failing.
The method is also static because the DLL may not understand how to be "created", as DLLs can be created in different languages. This  allows the method to be called directly, instead of being instantiated and then used.

The false keyword is a boolean constant value.

The keyword finally is used to identify a statement or statement block after a try-catch block for execution regardless of whether the associated try block encountered an exception, and executes even after a return statement. The finally block is used to perform cleanup activities.

The fixed keyword is used to prevent the garbage collector from relocating a variable. You may only use this in an unsafe context.

If you are using C# 2.0 or greater, the fixed may also be used to declare a fixed-size array. This is useful when creating code that works with a COM project or DLL.
Your array must be composed of one of the primitive types: bool, byte, char, double, float, int, long, sbyte, short, ulong, or ushort.

The float keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Single. That is, it represents a IEEE 754, 32-bit signed binary floating point number whose value is negative 0, positive 0, negative infinity, positive infinity, not a number, or a number ranging either from 
    {\displaystyle -1.5\times 10^{-45}}
    {\displaystyle -3.4\times 10^{38}}
   or from 
    {\displaystyle 1.5\times 10^{-45}}
    {\displaystyle 3.4\times 10^{38}}

The for keyword identifies a for loop. 	

The foreach keyword identifies a foreach loop.

The goto keyword returns the flow of operation to the label which follows it. Labels can be created by putting a colon after any word. e.g.

The use of goto is very controversial, because, when used frivolously, it creates code that jumps from place to place and is disorganized and hard to read. It is rarely even necessary because the same thing can often be accomplished with a more organized for loop or while loop. 	

The if keyword identifies an if statement with the following syntax:

if-statement ::= "if" "(" condition ")" if-body ["else" else-body]
condition ::= boolean-expression
if-body ::= statement-or-statement-block
else-body ::= statement-or-statement-blockIf the condition evaluates to true, the if-body executes. Curly braces ("{" and "}") allow the if-body to contain more than one statement. Optionally, an else clause can immediately follow the if-body, providing code to execute when the condition is false. Making the else-body another if statement creates the common cascade of if, else if, else if, else if, else statements:

The boolean expression used in an if statement typically contains one or more of the following operators:

See also else. 	

=== General ===
When values are cast implicitally, the runtime does not need any casting in code by the developer in order for the value to be converted to its new type.
Here is an example, where the developer is casting explicitly:

The developer has told the runtime, "I know what I'm doing, force this conversion."
Implicit casting means that runtime doesn't need any prompting in order to do the conversion. Here is an example of this.

Notice that no casting was necessary by the developer. What is special about implicit is that the context that the type is converted to is totally lossless, i.e. converting to this type loses no information. So, it can be converted back without worry.

=== Keyword ===
The keyword implicit is used for a type to define how to can be converted implicitly. It is used to define what types can be converted to without the need for explicit casting.
As an example, let us take a Fraction class, that will hold a nominator (the number at the top of the division), and a denominator (the number at the bottom of the division). We will add a property so that the value can be converted to a float.

To re-iterate, the value it implicitally casts to must hold data in the form that the original class can be converted back to. If this is not possible, and the range is narrowed (like converting double to int), use the explicit operator. 	

The in keyword identifies the collection to enumerate in a foreach loop.  
The in keyword may also be used in a query, e.g., 'from item in dataset'. Immediately following the contextual keyword from is a range variable representing one item in the dataset. The dataset to be queried is defined immediately following the contextual keyword in. See also ascending, descending, in, orderby, select, and where. 	

The int keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Int32. That is, it represents a 32-bit signed integer whose value ranges from -2,147,483,648 to 2,147,483,647.

The interface keyword is used to declare an interface. Interfaces provide a construct for a programmer to create types that can have methods, properties, delegates, events, and indexers declared, but not implemented.
It is a good programming practice to give interfaces differing names from classes that start with an I and/or finish with ...able, like IRun or Runnable or IRunnable. 	

The  internal keyword is an access modifier used in field, method, and property declarations to make the field, method, or property internal to its enclosing assembly. That is, it is only visible within the assembly that implements it. 	

The is keyword compares an object to a type, and if they're the same or of the same "kind" (the object inherits the type), returns true. The keyword is therefore used to check for type compatibility, usually before casting (converting) a source type to a destination type in order to ensure that won't cause a type-cast exception to be thrown. Using is on a null variable always returns false.
This code snippet shows a sample usage:


The lock keyword allows a section of code to exclusively use a resource, a feature useful in multi-threaded applications. If a lock to the specified object is already held when a piece of code tries to lock the object, the code's thread is blocked until the object is available.

The parameter to the lock statement must be an object reference, not a value type:


The long keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Int64. That is, it represents a 64-bit signed integer whose value ranges from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

The namespace keyword is used to supply a namespace for class, structure, and type declarations. 	

The new keyword has two different meanings:

It is an operator that requests a new instance of the class identified by its argument.
It is a modifier that explicitly hides a member.As an example, see the code below:


The null keyword represents an empty value for a reference type variable, i.e. for a variable of any type derived from System.Object. In C# 2.0, null also represents the empty value for nullable value type variables. 	

The object keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Object. That is, it represents the base class from which all other reference types derive. On some platforms, the size of the reference is 32 bits, while on other platforms it is 64 bits. 	

The operator keyword allows a class to overload arithmetic and cast operators:

The out keyword explicitly specifies that a variable should be passed by reference to a method, and set in that method. A variable using this keyword must not be intialized before the method call to ensure the developer understand its intended effects. Using this keyword requires the called method to set the variable using this modifier before returning. Using out also requires the developer to specify the keyword even in the calling code, to ensure that it is easily visible to developers reading the code that the variable will have its value changed elsewhere, which is useful when analyzing the program flow.
An example of passing a variable with out follows:

The keyword override is use in declaring an overridden function, which extends a base class function of the same name.

Further readingInheritance keywords

The keyword params is used to describe when a grouping of parameters are passed to a method, but the number of parameters are not important, as they may vary. Since the number isn't important, the params keyword must be the last variable in a method signature so that the compiler can deal with the parameters which have been defined first, before dealing with the params.
Here are examples of where it will, and will not work:

A good example of this is the String.Format method. The String.Format method allows a user to pass in a string formatted to their requirements, and then many parameters for the values to insert into the string. Here is an example:

The String.Format method has taken a string, and replaced the {0}, {1}, {2} with the 1st, 2nd and 3rd parameters. If the params keyword did not exist, then the String.Format() would need an infinite number of overloads to cater for each case.


The private keyword is used in field, method, and property declarations to make the field, method, or property private to its enclosing class. That is, it is not visible outside of its class. 	

The protected keyword is used in field, method, and property declarations to make the field, method, or property protected to its enclosing class. That is, it is not visible outside of its class.

The public keyword is used in field, method, and property declarations to make the field, method, or property public to its enclosing class. That is, it is visible from any class. 	

The readonly keyword is closely related to the const keyword at a glance, with the exception of allowing a variable with this modifier to be initialized in a constructor, along with being associated with a class instance (object) rather than the class itself.
The primary use for this keyword is to allow the variable to take on different values depending on which constructor was called, in case the class has many, while still ensuring the developer that it can never intentionally or unintentionally be changed in the code once the object has been created.
This is a sample usage, assumed to be in a class called SampleClass:


The ref keyword explicitly specifies that a variable should be passed by reference rather than by value.
A developer may wish to pass a variable by reference particularly in case of value types. If a variable is passed by reference, only a pointer is sent to a function in reality, reducing the cost of a method call in case it would involve copying large amounts of data, something C# does when normally passing value types.
Another common reason to pass a variable by reference is to let the called method modify its value. Because this is allowed, C# always enforces specifying that a value is passed by reference even in the method call, something many other programming languages don't. This let developers reading the code easily spot places that can imply a type has had its value changed in a method, which is useful when analyzing the program flow.
Passing a value by reference does not imply that the called method has to modify the value; see the out keyword for this.
Passing by reference requires the passed variable to be initialized.
An example of passing a variable by reference follows:


The return keyword is used to return execution from a method or from a property accessor. If the method or property accessor has a return type, the return keyword is followed by the value to return. 	

The sbyte keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.SByte. That is, it represents an 8-bit signed integer whose value ranges from -128 to 127.

The sealed keyword is used to specify that a class cannot be inherited from. The following example shows the context in which it may be used:

Notice: The sealed class inheritance is the same as that of a final class in Java. 	

The short keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.Int16. That is, it represents a 16-bit signed integer whose value ranges from -32,768 to 32,767. 	

The sizeof keyword returns how many bytes an object requires to be stored.
An example usage:


The keyword stackalloc is used in an unsafe code context to allocate a block of memory on the stack. 

In the example above, a block of memory of sufficient size to contain 100 elements of type int is allocated on the stack, not the heap; the address of the block is stored in the pointer fib. This memory is not subject to garbage collection and therefore does not have to be pinned (via fixed). The lifetime of the memory block is limited to the lifetime of the method in which it is defined (there is no way to free the memory before the method returns).
stackalloc is only valid in local variable initializers.
Because Pointer types are involved, stackalloc requires unsafe context. See Unsafe Code and Pointers.
stackalloc is similar to _alloca in the C run-time library.
Note* - From MSDN

The static keyword is used to declare a class or a class member (method, property, field, or variable) as static. A class that is declared static has only static members, and these are associated with the entire class instead of class instances. 	

The string keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for System.String. That is, it indicates an immutable sequence of characters. 	

The struct keyword declares a structure, i.e. a value type that functions as a light-weight class. 	

The switch statement is a control statement that handles multiple selections and enumerations by passing control to one of the case statements within its body.
This is an example of a switch statement:

Console Output
You're finally an adult! 	

The this keyword is used in an instance method or instance property to refer to the current class instance. That is, this refers to the object through which its containing method or property was invoked. It is also used to define extension methods.

The throw keyword is used to throw an exception object. 	

The true keyword is a Boolean constant value. Therefore

would create an infinite loop. 	

The try keyword is used to identify a statement or statement block as the body of an exception handling sequence. The body of the exception handling sequence must be followed by a catch clause, a finally clause, or both.

The typeof keyword returns an instance of the System.Type class when passed a name of a class. It is similar to the sizeof keyword in that it returns a value instead of starting a section (block) of code (see if, try, while).
An example:

The output will be:


It should be noted that unlike sizeof, only class names themselves and not variables can be passed to typeof as shown here:

using System;

namespace MyNamespace
    class MyClass2
        static void Main(string[] args)
            char ch;
            // This line will cause compilation to fail
            Type t = typeof(ch);

Sometimes, classes will include their own GetType() method that will be similar, if not identical, to typeof. 	

The uint keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.UInt32. That is, it represents a 32-bit unsigned integer whose value ranges from 0 to 4,294,967,295.

The ulong keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.UInt64. That is, it represents a 64-bit unsigned integer whose value ranges from 0 to 18,446,744,073,709,551,615. 	

The unchecked keyword prevents overflow-checking when doing integer arithmetics. It may be used as an operator on a single expression or as a statement on a whole block of code.


The unsafe keyword may be used to modify a procedure or define a block of code which uses unsafe code.  Code is unsafe if it uses the "address of" (&) or pointer operator (*).
In order for the compiler to compile code containing this keyword, you must use the unsafe option when using the Microsoft C-Sharp Compiler.


The ushort keyword is used in field, method, property, and variable declarations and in cast and typeof operations as an alias for the .NET Framework structure System.UInt16. That is, it represents a 16-bit unsigned integer whose value ranges from 0 to 65,535. 	

The using keyword has two completely unrelated meanings in C#, depending on if it is used as a directive or a statement.

== The directive ==
using as a directive resolves unqualified type references so that a developer doesn't have to specify the complete namespace.

using can also provide a namespace alias for referencing types.

== The statement ==
using as a statement automatically calls the dispose on the specified object. The object must implement the IDisposable interface. It is possible to use several objects in one statement as long as they are of the same type.

The var keyword can be used in place of a type when declaring a variable to allow the compiler to infer the type of the variable. This feature can be used to shorten variable declarations, especially when instantiating generic types, and is even necessary with LINQ expressions (since queries may generate very complex types).
The following:

is equivalent to:

var does not create a "variant" type; the type is simply inferred by the compiler. In situations where the type cannot be inferred, the compiler generates an error:

Note: Var is not a keyword 	

The keyword virtual is applied to a method declaration to indicate that the method may be overridden in a subclass. If the virtual keyword is not applied and a method is defined in a subclass with the same signature as the one in the parent class, the method in the parent class is hidden by the subclass implementation. With other words, it is only possible to have a true polymorphism of functions with this keyword.
Notice: Comparing it with Java, a method is not virtual if and only if it is final. This is the result of different design philosophies. 	

The void keyword is used in method signatures to declare a method that does not return a value. A method declared with the void return type cannot provide any arguments to any return statements they contain.


The volatile keyword is used to declare a variable that may change its value over time due to modification by an outside process, the system hardware, or another concurrently running thread.
You should use this modifier in your member variable declaration to ensure that whenver the value is read, you are always getting the most recent (up-to-date) value of the variable.

This keyword has been part of the C# programming language since .NET Framework 1.1 (Visual Studio 2003). 	

The while keyword identifies a while loop.
Special C# Identifiers

The add and remove keywords allow you to execute code whenever a delegate is added or removed from an event. Its usage is similar to the get and set keywords with properties:

The code in the add block will be executed when a delegate is added to the event. Similarly, the code in the remove block will be executed when a delegate is removed from the event. 	
The alias keyword is used to indicate an external alias.
When you need to use several versions of the same assembly or assemblies with the same full qualified typenames, you need to use the alias and extern keywords to give different alias names for each version.

To use the typenames of each version, you have the operator :: .

However, this only says to the compiler that there are several assemblies with typename conflicts. To relate what of each assemblies match's the alias name, you have to tell the compiler on its options apart the source. On dotNet command line, this options would be:

/r:AppTools=AppToolsv100.dll /r:AppToolsV2=AppToolsv200.dll

In order for it to be of use, you need to provide an external assembly to the compiler (e.g. pass /r:EXTALIAS=XXX.dll) and identify the external alias within the code (e.g. extern alias EXTALIAS;) 	

The special identifier get is used to declare the read accessor for a property. 	

The global keyword is useful in some contexts to resolve ambiguity between identifiers. If you have a conflict between a class name and a namespace, for example, you can use the global keyword to access the namespace:

global does not work in the following situation, however, as our System class does not have a namespace:


The special identifier partial is used to allow developers to build classes from different files and have the compiler generate one class, combining all the partial classes. This is mostly useful for separating classes into separate blocks. For example, Visual Studio 2005 separates the UI code for forms into a separate partial class that allows you to work on the business logic separately.

The special identifier set is used to declare the write accessor for a property. 	

The special identifier value is used in a property's write accessor to represent the value requested for assignment to the property. 	

The where keyword has two different meanings:

It is used to specify one or more constraints on generic type parameters.
With LINQ, it is used to query a data source and select or filter elements to return.
The yield keyword returns the next value from an iterator or ends an iteration.

== Notes ==
The reference list of C# keywords is at [2].

== References ==