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