New Features in C# 3.0, 4.0 and 5.0 (英文差的免入)

What’s New in C# 3.0

Language Integrated Query(LINQ)

- LINQ enables queries to be written in C# program to query both local collections
(such as lists or XML documents) or remote data sources (such as a database)

Implicitly typed local variables

- let you omit the variable type in a declaration statement, allowing the compiler to infer it

Object initializers

- simplify object construction by allowing properties to be set inline after the constructor call

Lambda expressions

- miniature functions created by the compiler on the fly, and are particularly useful in “fluent” LINQ queries

Extension methods

- extend an existing type with new methods, making static methods feel like instance methods

Query expressions

- provide a higher-level syntax for writing LINQ queries that can be substantially simpler when working

with multiple sequences or range
variables

Expression trees

- miniature code DOMs that describe lambda expressions assigned to the

special type Expression<TDelegate>

Expression trees make it possible for LINQ queries to execute remotely

Automatic properties

- cut the work in writing properties that simply get/set a private backing field by having the compiler do that work automatically

Partial methods

- let an auto-generated partial class provide customizable hooks for manual authoring which “melt away” if unused

What’s New in C# 4.0

Dynamic binding

- defers binding

Optional parameters

- allow functions to specify default parameter values so that callers can omit arguments and named arguments

allow a function caller to identify an argument by name rather than position

Type variance rules

- type parameters in generic interfaces and generic delegates can be marked as covariant or
contravariant, allowing more natural type conversions

COM interoperability

What’s New in C# 5.0

C# 5.0’s big new feature is support for asynchronous functions via two new
keywords, async and await. Asynchronous functions enable asynchronous continuations,
which make it easier to write responsive and thread-safe rich-client applications.
They also make it easy to write highly concurrent and efficient I/O-bound
applications that don’t tie up a thread resource per operation