C Sharp 3.0

From Wikipedia, the free encyclopedia
Jump to: navigation, search
The correct title of this article is C# 3.0. The substitution or omission of the # is because of technical restrictions.

The programming language C# version 3.0 was released on 19 November 2007 as part of .NET Framework 3.5. 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.[1] It is not currently standardized by any standards organisation.

C# 3.0 features[edit]

LINQ (language-integrated query)[edit]

LINQ is a new Microsoft-specific extensible, general-purpose query language for many kinds of data sources—including plain object collections, XML documents, databases, etc.—which is tightly integrated with other C# language facilities. The syntax is different from, but borrows from SQL. An example:

int[] array = { 1, 5, 2, 10, 7 };
 
// Select squares of all odd numbers in the array sorted in descending order
IEnumerable<int> query = from x in array
                         where x % 2 == 1
                         orderby x descending
                         select x * x;
// Result: 49, 25, 1

To implement LINQ, a large range of new methods were added to many collections via the System.Linq.Enumerable class. LINQ expressions are translated to use these functions before compilation. As an alternative, which is sometimes more powerful or direct, these functions may be accessed directly.[2] Doing so makes more use of lambda functions, which are discussed below. The following is functionally identical to the example above.

IEnumerable<int> query = array.Where(x => x % 2 == 1).OrderByDescending(x => x).Select(x => x * x);
// Result: 49, 25, 1 using 'array' as defined in previous example

Object initializers[edit]

Customer c = new Customer(); 
c.Name = "John";

can be written

Customer c = new Customer { Name = "John" };

Collection initializers[edit]

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.[3]

Anonymous types[edit]

Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to first explicitly define a type. The type name is generated by the compiler and is not available at the source code level. The type of the properties is inferred by the compiler.

var x = new { FirstName = "John", LastName = "Doe" };

Anonymous types are reference types that derive directly from object. The compiler gives them a name although your application cannot access it. From the perspective of the common language runtime, an anonymous type is no different from any other reference type, except that it cannot be cast to any type except for object.

If two or more anonymous types have the same number and type of properties in the same order, the compiler treats them as the same type and they share the same compiler-generated type information.[4]

Local variable type inference[edit]

Local variable type inference:

var x = new Dictionary<string, List<float>>();

is interchangeable with

Dictionary<string, List<float>> x = new Dictionary<string, List<float>>();

This feature is not just a convenient syntactic sugar for shorter local variable declarations, but it is also required for the declaration of variables of anonymous types. The contextual keyword "var", however, may only appear within a local variable declaration.

Lambda expressions[edit]

Lambda expressions provide a concise way to write first-class anonymous function values. Compare the following C# 2.0 snippet:

listOfFoo.Where(delegate(Foo x) { return x.Size > 10; });

with this C# 3.0 equivalent:

listOfFoo.Where(x => x.Size > 10);

In the above examples, lambda expressions are merely shorthand syntax for anonymous delegates with type inference for parameters and return type. However, depending on the context they are used in, a C# compiler can also transform lambdas into ASTs that can then be processed at run-time. In the example above, if listOfFoo is not a plain in-memory collection, but a wrapper around a database table, it could use this technique to translate the body of the lambda into the equivalent SQL expression for optimized execution. Either way, the lambda expression itself looks exactly the same in the code, so the way it is used at run-time is transparent to the client.

Expression trees[edit]

Expressions, such as x <= y, a = b + c, or even lambda functions and other complex forms can be created dynamically using expression trees. Much of the functionality is provided by static methods of the class System.Linq.Expressions.Expression. There are also various new classes in that namespace that represent the expressions and partial expressions created by those methods as software objects. These include BinaryExpression, which could represent x <= y; LambdaExpression and many others. When combined with aspects of the reflection API, this can be a very powerful tool, if a little challenging to write and debug.[5][6]

Automatic properties[edit]

The compiler generates a private instance variable and the appropriate accessor and mutator given code such as:

public string Name { get; private set; }

Extension methods[edit]

Developers may use extension methods to add new methods to the public contract of an existing CLR type, without having to sub-class it or recompile the original type. In reality, extension methods are a form of syntactic sugar that provide the illusion of adding new methods to the existing class outside its definition. The illusion is achieved with the definition of a static method that is callable as if it were an instance method, where the receiver of the call (i.e., the instance) is bound to the first parameter of the method, decorated with keyword this.

The requirements for an extension method are as follows:

  1. An extension method must be defined in a static class.
  2. An extension method must be defined as a static method.
  3. An extension method's first parameter must take the following form, where type is the name of the type to be extended:

    this type parameterName

  4. An extension method may optionally define other parameters to follow the this parameter.

This example class demonstrates the definition and use of a Left extension method for strings:

public static class StringExtensions
{
    public static string Left(this string s, int n)
    {
        return s.Substring(0, n);
    }
}
 
string s = "foo bar";
s.Left(3); // same as StringExtensions.Left(s, 3), which returns "foo";

Partial methods[edit]

Partial methods allow code generators to generate method declarations as extension points that are only included in the compilation if someone actually implements them in another portion of a partial class.[7]

References[edit]

  1. ^ Anderson, Tim (2006-11-14). "C# pulling ahead of Java - Lead architect paints rosy C# picture". Reg Developer. The Register. Retrieved 2007-01-20. 
  2. ^ Walther, Stephen (2008). ASP.NET 3.5 Unleashed. Indiana, USA: SAMS. pp. 916–917. ISBN 978-0-672-33011-7. "I find that I use method syntax more than query syntax because query syntax is a subset of method syntax." 
  3. ^ Torgersen, Mads (2006-10-10). "What is a collection?". The Mellow Musings of Dr. T. Retrieved 2009-06-18. 
  4. ^ "Anonymous Types". C# Programming Guide. Microsoft. July 2008. Retrieved 2009-06-18. 
  5. ^ Walther, Stephen (2008). ASP.NET 3.5 Unleashed. Indiana, USA: SAMS. pp. 950–952. ISBN 978-0-672-33011-7. 
  6. ^ "Expression Trees". .NET Framework Developer's Guide. Microsoft. Retrieved 2009-04-26. 
  7. ^ "Partial Classes and Methods". C# Programming Guide. Microsoft. Retrieved 2009-04-28. 

External links[edit]