C#

 

C#

Paradigm:	structured, imperative, object-oriented
Appeared in:	2001 (last revised 2005)
Designed by:	Microsoft Corporation
Typing discipline:	static, strong, both safe and unsafe, nominative
Major implementations:	.NET Framework, Mono, DotGNU
Dialects:	1.0, 1.5 , 2.0 (ECMA)
Influenced by:	Delphi, [[C++]], Java, Modula-3, Eiffel
Influenced:	Nemerle, D, Java[1]

C# (see section on name, pronunciation) is an object-oriented programming language developed by Microsoft as part of the .NET initiative and later approved as a standard by ECMA and ISO. Anders Hejlsberg leads development of the C# language, which has a procedural, object-oriented syntax based on [[C++]] and includes aspects of several other programming languages (most notably Delphi and Java) with a particular emphasis on simplification.

This article describes the C# language as defined in the ECMA and ISO standards. For a description of Microsoft's implementation, see Microsoft Visual C#.

Design goals

The ECMA standard lists these design goals for C#:

• C# is intended to be a simple, modern, general-purpose, object-oriented programming language.
• Because software robustness, durability and programmer productivity are important. The language should include strong type checking, array bounds checking, detection of attempts to use uninitialized variables, source code portability, and automatic garbage collection.
• The language is intended for use in developing software components that can take advantage of distributed environments.
• Programmer portability is very important, especially for those programmers already familiar with C and C++.
• Support for internationalization is very important.
• C# is intended to be suitable for writing applications for both hosted and embedded systems, ranging from the very large that use sophisticated operating systems, down to the very small having dedicated functions.
• Although C# applications are intended to be economical with regards to memory and processing power requirements, the language was not intended to compete directly on performance and size with C or assembly language.

Architectural history

C#'s principal designer and lead architect at Microsoft is Anders Hejlsberg. His previous experience in programming language and framework design ([[Visual J++]], Borland Delphi, Turbo Pascal) can be readily seen in the syntax of the C# language, as well as throughout the Common Language Runtime (CLR) core. In interviews and technical papers he has stated that flaws in most major programming languages (e.g. [[C++]], Java, Delphi, and Smalltalk) drove the fundamentals of the CLR, which, in turn, drove the design of the C# programming language itself. Some argue that C# shares roots in other languages.^[2]

Features

The following description is based on the language standard and other documents listed in the External Reference section.

By design, C# is the programming language that most directly reflects the underlying Common Language Infrastructure (CLI). Most of C#'s intrinsic types correspond to value-types implemented by the CLI framework. However, the C# language specification does not state the code generation requirements of the compiler: that is, it does not state that a C# compiler must target a Common Language Runtime (CLR), or generate Common Intermediate Language (CIL), or generate any other specific format. Theoretically, a C# compiler could generate machine code like traditional compilers of C++ or FORTRAN; in practice, all existing C# implementations target CLI.

C# differs from C and C++ in many ways, including:

• There are no global variables or functions. All methods and members must be declared within classes.
• Local variables cannot shadow variables of the enclosing block, unlike C and C++. Variable shadowing is often considered confusing by C++ texts.
• C# supports a strict boolean type, bool. Statements that take conditions, such as while and if, require an expression of a boolean type. While C++ also has a boolean type, it can be freely converted to and from integers, and expressions such as if(a) require only that a is convertible to bool, allowing a to be an int, or a pointer. C# disallows this 'integer meaning true or false' approach on the grounds that forcing programmers to use expressions that return exactly bool prevents certain types of programming mistakes.
• In C#, pointers can only be used within blocks specifically marked as unsafe, and programs with unsafe code need appropriate permissions to run. Most object access is done through safe references, which cannot be made invalid. An unsafe pointer can point to an instance of a value-type, array, string, or a block of memory allocated on a stack. Code that is not marked as unsafe can still store and manipulate pointers through the System.IntPtr type, but cannot dereference them.
• Managed memory cannot be explicitly freed, but is automatically garbage collected. Garbage collection addresses memory leaks. C# also provides direct support for deterministic finalization with the using statement (supporting the Resource Acquisition Is Initialization idiom).
• Multiple inheritance is not supported, although a class can implement any number of interfaces. This was a design decision by the language's lead architect to avoid complication, avoid dependency hell and simplify architectural requirements throughout CLI.
• C# is more typesafe than C++. The only implicit conversions by default are safe conversions, such as widening of integers and conversion from a derived type to a base type. This is enforced at compile-time, during JIT, and, in some cases, at runtime. There are no implicit conversions between booleans and integers and between enumeration members and integers (except 0, which can be implicitly converted to an enumerated type), and any user-defined conversion must be explicitly marked as explicit or implicit, unlike C++ copy constructors (which are implicit by default) and conversion operators (which are always implicit).
• Enumeration members are placed in their own namespace.
• Accessors called properties can be used to modify an object with syntax that resembles C++ member field access. In C++, declaring a member public enables both reading and writing to that member, and accessor methods must be used if more fine-grained control is needed. In C#, properties allow control over member access and data validation.
• Full type reflection and discovery is available.

Unified type system

C# has a unified type system. This means that all types, including primitives such as integers, are subclasses of the System.Object class. For example, every type inherits a ToString() method. For performance reasons, primitive types (and value types in general) are internally allocated on the stack. Boxing and unboxing allow one to translate primitive data to and from their object form. Effectively, this makes the primitive types a subtype of the Object type. Primitive types can also define methods (e.g., 42.ToString() calls the ToString() method on an integer), and in the programmer's perspective behave like any other object.

C# allows the programmer to create user-defined value types, using the struct keyword. From the programmer's perspective, they can be seen as lightweight classes. Unlike regular classes, and like the standard primitives, such value types are allocated on the stack rather than on the heap. They can also be part of an object (either as a field or boxed), or stored in an array, without the memory indirection that normally exists for class types. Structs also come with a number of limitations. Because structs have no notion of a null value and can be used in arrays without initialization, they are implicitly initialized to default values (normally by filling the struct memory space with zeroes, but the programmer can specify explicit default values to override this). The programmer can define additional constructors with one or more arguments. This also means that structs lack a virtual method table, and because of that (and the fixed memory footprint), they cannot allow inheritance (but can implement interfaces).

C# 2.0 new language features

New features in C# for the .NET SDK 2.0 (corresponding to the 3rd edition of the ECMA-334 standard) are:

• Partial classes allow class implementation across more than one file. This permits breaking down very large classes, or is useful if some parts of a class are automatically generated.

file1.cs:

<source lang="csharp"> public partial class MyClass {

   public MyClass()
   {
       // implementation
   }

} </source>

file2.cs:

<source lang="csharp"> public partial class MyClass {

   public void SomeMethod()
   {
       // implementation
   }

} </source>

• Generics or parameterized types. This is a .NET 2.0 feature supported by C#. Unlike C++ templates, .NET parameterized types are instantiated at runtime rather than by the compiler; hence they can be cross-language whereas C++ templates cannot. They support some features not supported directly by C++ templates such as type constraints on generic parameters by use of interfaces. On the other hand, C# does not support non-type generic parameters. Unlike generics in Java, .NET generics use reification to make parameterized types first-class objects in the CLI Virtual Machine, which allows for optimizations and preservation of the type information.
• Static classes that cannot be instantiated, and that only allow static members. This is similar to the concept of module in many procedural languages.
• A new form of iterator that provides generator functionality, using a yield return construct similar to yield in Python.

<source lang="csharp"> // Method that takes an iterable input (possibly an array) and returns all even numbers. public static IEnumerable<int> GetEven(IEnumerable<int> numbers) {

   foreach (int i in numbers)
   {
       if (i % 2 == 0) yield return i;
   }

} </source>

• Anonymous delegates providing closure functionality.

<source lang="csharp"> public void Foo(object parameter) {

   // ...

   ThreadPool.QueueUserWorkItem(delegate
   {
       // anonymous delegates have full access to local variables of the enclosing method
       if (parameter == ...)
       { 
           // ... 
       }

       // ...
   });

} </source>

• Covariance and contravariance for signatures of delegates
• The accessibility of property accessors can be set independently. Example:

<source lang="csharp"> string status = string.Empty;

public string Status {

   get { return status; }             // anyone can get value of this property,
   protected set { status = value; }  // but only derived classes can change it

} </source>

• Nullable value types (denoted by a question mark, e.g. int? i = null;) which add null to the set of allowed values for any value type. This provides improved interaction with SQL databases, which can have nullable columns of types corresponding to C# primitive types: an SQL INTEGER NULL column type directly translates to the C# int?.

Nullable types received an eleventh-hour improvement at the end of August 2005, mere weeks before the official launch, to improve their boxing characteristics: a nullable variable which is assigned null is not actually a null reference, but rather an instance of struct Nullable<T> with property HasValue equal to false. When boxed, the Nullable instance itself is boxed, and not the value stored in it, so the resulting reference would always be non-null, even for null values. The following code illustrates the corrected flaw:

<source lang="csharp"> int? i = null; object o = i; if (o == null)

   Console.WriteLine("Correct behaviour - runtime version from September 2005 or later");

else

   Console.WriteLine("Incorrect behaviour - pre-release runtime (from before September 2005)");

</source>

When copied into objects, the official release boxes values from Nullable instances, so null values and null references are considered equal. The late nature of this fix caused some controversy^{[citation needed]}, since it required core-CLR changes affecting not only .NET2, but all dependent technologies (including C#, VB, SQL Server 2005 and Visual Studio 2005).

• Coalesce operator: (??) returns the first of its operands which is not null:

<source lang="csharp"> object nullObj = null; object obj = new Object(); return nullObj ?? obj; // returns obj </source>

The primary use of this operator is to assign a nullable type to a non-nullable type with an easy syntax:

<source lang="csharp"> int? i = null; int j = i ?? 0; // Unless i is null, initialize j to i. Else (if i is null), initialize j to 0. </source>

C# 3.0 new language features

This article contains information about a scheduled or expected future product. It may contain preliminary information that does not reflect the final version of the product.

C# 3.0 is the next version of the language as proposed by Microsoft. It includes new features inspired by functional programming languages such as Haskell and ML, and is driven largely by the introduction of the Language Integrated Query (LINQ) pattern to the Common Language Runtime.^[3]

• Language Integrated Query:^[4] "from, where, select" context-sensitive keywords allowing queries across SQL, XML, collections, and more. These are treated as keywords in the LINQ context, but their addition won't break existing variables named from, where, or select.
• Object initializers: Customer c = new Customer(); c.Name = "James"; can be written Customer c = new Customer { Name="James" };
• Collection initializers: MyList list = new MyList(); list.Add(1); list.Add(2); can be written as MyList list = new MyList { 1, 2 }; (assuming that MyList implements System.Collections.IEnumerable and has a public Add method^[5])
• Anonymous types: var x = new { Name = "James" }
• Local variable type inference: var x = "hello"; is interchangeable with string x = "hello";. More than just syntactic sugar, this feature is required for the declaration of anonymous typed variables.
• Implicitly-typed arrays: The type of an array can now be omitted, so that int[] arr = new int[] { 1, 2, 3 } can now be written as var arr = new[] { 1, 2, 3 }.
• Lambda expressions: listOfFoo.Where(delegate(Foo x) { return x.size > 10; }) can be written listOfFoo.Where(x => x.size > 10);
• Compiler-inferred translation of Lambda expressions to either strongly-typed function delegates or strongly-typed expression trees
• Automatic properties: The compiler will automatically generate a private instance variable and the appropriate getter and setter given code such as: public string Name { get; private set; }
• Extension methods (adding methods to classes by including the this keyword in the first parameter of a method on another static class):

<source lang="csharp"> public static class IntExtensions {

   public static void PrintPlusOne(this int x) { Console.WriteLine(x + 1); }

}

int foo = 0; foo.PrintPlusOne(); </source>

• Partial methods: Allow codegenerators to generate method declarations as extension points that are only included in the source code compilation if someone actually implements it in another portion of a partial class.^[6]

C# 3.0 was unveiled at the 2005 Professional Developers Conference. A preview with specifications is available from the Visual C# site at Microsoft. It is not currently standardized by any standards organisation, though it is expected that it will eventually become an ECMA and then ISO standard, as did its predecessors.

Microsoft has emphasized that the new language features of C# 3.0 will be available without any changes to the runtime. This means that C# 2.0 and 3.0 will be binary-compatible (CLI implementations compatible with 2.0 are able to run 3.0 applications directly).

Although the new features may only slightly change simple in-memory queries, such as List.FindAll or List.RemoveAll, the pattern used by LINQ allows for significant extension points to enable queries over different forms of data, both local and remote.

Preprocessor

C# features "preprocessor directives"^[7] (though it does not have an actual preprocessor) based on the C preprocessor that allows programmers to define symbols but not macros. Conditionals such as #if, #elif, and #else are also provided. Directives such as #region give hints to editors for code folding.

XML documentation system

C#'s documentation system is similar to Java's Javadoc, but based on XML. Multiline comments beginning with /** and single line comments beginning with /// are treated as documentation.

<source lang="csharp"> public class Foo {

   /// <summary>A summary of the method.</summary>
   /// <param name="firstParam">A description of the parameter.</param>
   /// <remarks>Remarks about the method.</remarks>
   public static void Bar(int firstParam) {}

} </source>

Syntax for documentation comments and their XML markup is defined in a non-normative annex of the ECMA C# standard. The same standard also defines rules for processing of such comments, and their transformation to a plain XML document with precise rules for mapping of CLI identifiers to their related documentation elements. This allows any C# IDE or other development tool to find documentation for any symbol in the code in a certain well-defined way.

Code libraries

The C# specification details a minimum set of types and class libraries that the compiler expects to have available and they define the basics required. In practice, C# is most often used with some implementation of the Common Language Infrastructure (CLI), which is standardized as ECMA-335 Common Language Infrastructure (CLI).

Hello world example

The following is a very simple C# program, a version of the classic "Hello world" example:

<source lang="csharp"> class ExampleClass {

   static void Main()
   {
       System.Console.WriteLine("Hello, world!");
   }

} </source>

The effect is to write the following text to the output console:

Hello, world!

Each line has a purpose:

<source lang="csharp"> class ExampleClass </source>

Above is a class definition. Everything between the following pair of braces describes ExampleClass.

<source lang="csharp"> static void Main() </source>

This declares the class member method where the program begins execution. The .NET runtime calls the Main method. (Note: Main may also be called from elsewhere, e.g. from the code Main() in another method of ExampleClass.) The static keyword makes the method accessible without an instance of ExampleClass. Each console application's Main entry point must be declared static. Otherwise, the program would require an instance, but any instance would require a program. To avoid that irresolvable circular dependency, C# compilers run on console applications (like above) report an error if there is no static Main method. The void keyword declares that Main has no return value. (See also, Side effect (computer science).)

<source lang="csharp"> System.Console.WriteLine("Hello, world!"); </source>

This line writes the output. Console is a static class in the System namespace. It provides an interface to the standard input, output, and error streams for console applications. The program calls the Console method WriteLine, which displays on the console a line with the argument, the string "Hello, world!".

Standardization

In August, 2000, Microsoft Corporation, Hewlett-Packard and Intel Corporation co-sponsored the submission of specifications for C# as well as the Common Language Infrastructure (CLI) to the international standardization organization ECMA. In December 2001 , ECMA released ECMA-334 C# Language Specification. C# became an ISO standard in 2003 (ISO/IEC 23270). ECMA had previously adopted equivalent specifications as the 2nd edition of C#, in December, 2002.

In June 2005, ECMA approved edition 3 of the C# specification, and updated ECMA-334. Additions included partial classes, anonymous methods, nullable types, and generics (similar to C++ templates).

In July 2005, ECMA submitted the standards and related TRs to ISO/IEC JTC 1 via the latter's Fast-Track process. This process usually takes 6-9 months.

Criticism

Performance

• As with other Virtual Machine-based languages, C# programs are slower than for languages that compile directly into native code^[8].

Language

• Although primitive types are treated as Objects at the source level, which allows programmers to use them easily in contexts where only Objects are allowed (e.g., collections)^[9], this is done under the hood in the language by boxing/unboxing them at the bytecode level. The creation of additional objects has a negative effect on performance. This also leads to a lot of pitfalls where the program's behavior is not the same as expected^[10]. However, changes have been made since the introduction of generics in version 2.0.

Platform

• The reference .NET Microsoft implementation is only available on Windows. However, there are other implementations for running C# programs on Windows, Linux or MacOS X: Mono and DotGNU.

Licensing

• Although the C# language definition is standardized under an ISO standard, only a part of the Base Class Library, which contains the fundamental functions that are used by all C# programs (IO, User Interface, Web services, ...) is also standardized. Furthermore, parts of the BCL has been patented by Microsoft^[11][12], which may deter non-Microsoft implementations of the full framework.

Implementations

The de facto standard implementation of the C# language is Microsoft's C# compiler, included in every installation of .NET Framework. A version of which is used inside Microsoft's own Visual C# and Visual C# Express Edition IDEs, and directly invoked from Borland's C# Builder, and the open source SharpDevelop IDEs.

Alternative C# compilers are:

• Microsoft's Rotor project (currently called Shared Source Common Language Infrastructure) (licensed for educational and research use only) provides a shared source implementation of the CLR runtime and a C# compiler, and a subset of the required Common Language Infrastructure framework libraries in the ECMA specification.

• The Mono project provides an open source C# compiler (written in C# itself), a complete open source implementation of the Common Language Infrastructure including the required framework libraries as they appear in the ECMA specification, and a nearly complete^{[citation needed]} implementation of the remaining Microsoft proprietary .NET class libraries (libraries not documented or included in the ECMA specification but are included in Microsoft's standard .NET Framework distribution).

• The DotGNU project also provides an open source C# compiler (written in C), a nearly complete implementation of the Common Language Infrastructure including the required framework libraries as they appear in the ECMA specification, and subset of some of the remaining Microsoft proprietary .NET class libraries (libraries not documented or included in the ECMA specification but are included in Microsoft's standard .NET Framework distribution).

Language name

According to the ECMA-334 C# Language Specification, section 6, Acronyms and abbreviations^[13] the name of the language is written "C#" ("LATIN CAPITAL LETTER C (U+0043) followed by the NUMBER SIGN # (U+0023)") and pronounced "C Sharp".

Due to technical limitations of display (fonts, browsers, etc.) and the fact that the sharp symbol (♯, U+266F, MUSIC SHARP SIGN, see graphic at right if the symbol is not visible) is not present on the standard keyboard, the number sign (#) was chosen to represent the sharp symbol in the written name of the language. So, although the symbol in "C#" represents the sharp symbol, it is actually the number sign ("#"). Microsoft's C# FAQ refers to the sharp symbol in the language name.^[14] James Kovacs, a Microsoft MVP, explains some of the history of C#.^[15]

The choice to represent the sharp symbol (♯) with the number sign (#) has led to confusion regarding the name of the language. For example, although most printed literature uses the correct number sign,^[16] some incorrectly use the sharp symbol.^[17]

The "sharp" suffix has been used by a number of other .NET languages that are variants of existing languages, including J# (Microsoft's implementation of Java), A# (from Ada), and F# (presumably from System F, the type system used by the ML family)^[18]. The original implementation of Eiffel for .NET was called Eiffel#, a name since retired since the full Eiffel language is now supported. The suffix is also sometimes used for libraries, such as Gtk# (a .NET wrapper for [[GTK+]] and other GNOME libraries) and Cocoa# (a wrapper for Cocoa).

See also

• Comparison of C# and Java
• Comparison of C# and Visual Basic.Net
• Common Language Runtime
• C# Syntax
• Microsoft Visual Studio, IDE for C#
• SharpDevelop, an open-source C# IDE for Windows
• Mono, an open source implementation of .NET
• MonoDevelop, an open-source C# IDE for Linux
• Cω programming language, extension to C#
• Morfik C#, a C# to JavaScript compiler complete with IDE and framework for Web application development.
• F#, Microsoft's version of OCaml
• Spec#
• Sing#
• Nemerle programming language
• Baltie, an IDE for learning C# and young Baltie
• Boo programming language, a cross between C# and Python
• IronPython, a Microsoft-supported, .NET-compliant version of Python
• Polyphonic C#
• Anders Hejlsberg
• [[C++/CLI]]
• Comparison of programming languages
• Windows PowerShell, a .NET-based interactive command line shell/scripting environment
• Active record pattern, a pattern and some examples related to C# 3.0 features
• Java
• [[C++]]
• Visual Basic

References

External links

• C# Language (MSDN)
• C# Specification
• Hyperlinked ECMA C# Specifications (version 1.1)
• ECMA-334 C# Language SpecificationPDF (2.49 MiB)
• ISO C# Language Specification (for purchase)
• ISO C# Language Specification (for free)
• Microsoft Visual C# .NET
• MCS: The Mono C# compiler
• Generics in C#, Java, and C++ A Conversation with Anders Hejlsberg, Part VII Anders Hejlsberg, C#'s creator, discusses differences between the generics implementations in C#, Java, and C++.
• C# Online.NET - C# wiki
• dotGNU project

.NET Framework
Architecture	Base Class Library · Common Language Infrastructure · .NET assembly · .NET metadata
Common Language Infrastructure	Common Language Runtime · Common Type System · Common Intermediate Language · Virtual Execution System · Dynamic Language Runtime
Languages	C# · Cω · Visual Basic .NET · [[C++/CLI]] ([[Managed Extensions for C++|Managed]]) · J# · JScript .NET · Windows PowerShell · IronPython · IronRuby · F#
Other languages	A# · Boo · IronLisp · L# · Nemerle · P# · PHP · Scala
Windows Foundations	Presentation · Communication · Workflow
Components	ADO.NET · ASP.NET · .NET Remoting · Language Integrated Query · Silverlight · Windows CardSpace · Windows Forms · XAML · ClickOnce
Other implementations	DotGNU · Mono · .NET Compact Framework (Xbox 360) · .NET Micro Framework · Portable.NET · Shared Source Common Language Infrastructure
Comparison	C# vs. Java · C# vs. Visual Basic .NET · Comparison of the Java and .NET platforms
Upcoming technologies	Acropolis · Astoria · Jasper · Parallel FX Library (PLINQ · TPL) Burp

Donate to Wikimedia