C# 3.0 and VB 9.0 New Featuresof VS2008

C# and VB Feature List

C# 3.0 VB 9.0

Extension MethodsLambda ExpressionsLINQExpression Trees

Extension MethodsLambda ExpressionsLINQ and Embedded XML Expression Trees

Extension Methods

Extension Methods in C# Allows to extend existing types and constructed types with

additional methods, without having to sub-class it or recompile the original type

Static methods that can be invoked using instance method syntax

Extension Methods in C# Applied not just to individual types, but also to parent base

class or interface within DOTNET framework If “this” keyword precedes an “object”, then it indicates that

the extension method should be applied to all types that derive from the base System.Object base type. The method can be applied on every object in .NET

Powerful way to inject our own custom functionality into existing types

Functionally same as wrapper classes; only difference is Design time syntax

Extension method with same name as Class/Interface method will never be called.

Have lower priority than instance methods defined in type

Extension Methods in C# To add a new method to existing type, Create a static

method in a static class and import the namespace in the class in which it is needed

Extension Methods in VB Decorated with “Extension” attribute (in System.Runtime.CompilerServices) Preferred over Shared utility methods Should be in a Module

Pros of Extension Methods

Can be called on Null objectsComposability – Chaining of operationsLINQAdd functionality without altering existing code.NET types, third party types, older COM/Active X

types can be extendedProvide concrete implementation to interfaces

Cons of Extension MethodsNot a replacement to InheritanceCode Hijack / SecurityAdding a Real method to an object with same name

as extension method gives precedence for Real method

Properties cannot be extendedSimilar to Wrapper classes, only access public

methods and cannot read/write protected membersCounter-Intuitive – Specified in the order opposite to

the order of execution

Guidelines for Extension Method

Can be used to extend a class/interface but not to override them

Use sparingly only when you have to

Useful Extension Methods

http://www.extensionmethod.net/

Lambda Expressions

Lambda Expressions in C# 3.0 Compact way of writing functions in middle of expressions

and obtaining a delegate to function we write.

Lambda Expressions

A lambda expression is written as a parameter list

followed by => token and then followed by

an expression or statement block to be executed when statement is invoked.

Params=> expression

Lambda Expression• Add (a, b) => (a + b)• AddChecked (a, b) => (a + b)• And (a, b) => (a And b)• AndAlso (a, b) => (a && b)• ArrayIndex (a, i) => a[i]• ArrayLength a => ArrayLength(a)• Call a => Abs(a)• Coalesce s => (s ?? "(null)")• Conditional (b, t, f) => IIF(b, t, f)• Constant () => 123• Convert a => Convert(a)• ConvertChecked a => ConvertChecked(a)• Divide (a, b) => (a / b)• Equal (a, b) => (a = b)• ExclusiveOr (a, b) => (a ^ b)• GreaterThan (a, b) => (a > b)

Lambda Expression

• GreaterThanOrEqual (a, b) => (a >= b)• Invoke a => Invoke(a)• Lambda a => a• LeftShift (a, s) => (a << s)• LessThan (a, b) => (a < b)• LessThanOrEqual (a, b) => (a <= b)• ListInit () => new List`1() {Void Add(Int32)(1)}• MemberAccess m => m.i• MemberInit a => new MemberAccess() {i = a}• Modulo (a, b) => (a % b)• Multiply (a, b) => (a * b)• MultiplyChecked (a, b) => (a * b)• Negate a => -a• NegateChecked a => -a• New n => new String(a, n)

Lambda Expression• NewArrayBounds n => new System.Int32[*](n)• NewArrayInit () => new [] {}• Not b => Not(b)• NotEqual (a, b) => (a != b)• Or (a, b) => (a Or b)• OrElse (a, b) => (a || b)• Parameter a => a• Power (a, e) => (a ^ e)• Quote () => 1• RightShift (a, s) => (a >> s)• Subtract (a, b) => (a - b)• SubtractChecked (a, b) => (a - b)• TypeAs o => (o As String)• TypeIs o => (o Is String)• UnaryPlus a => +a

Lambda Expression - Features

First class citizens Can be returned from a function Can be passed to a function Can be used as Callback delegates Return statement in lambda expression does not return an

enclosing method Cannot contain goto statement/ break statement/ continue

statement whose target is outside the body or in the body of contained anonymous function

Lambda Expressions - Uses

Used In LINQ Query expressions Used in Construction of Expression trees Used in place of Delegates

Lambda Expressions - Cons

Can include only expressions and not statements Single Expressions in VB 9.0 Variable captured will not be garbage collected unless the

delegate that references it goes out of scope Variables inside lambda expression are not visible outside the

method Cannot capture ref or out parameter from an enclosing

method Recursive Lambda expressions cannot be written

LINQ

Language Integrated Query (LINQ)

Express efficient query behavior in programming language, transforms the query results into any format, and easily manipulate the results.

Full type safety and compile time checking of query expressions

LINQ query returns objects of type IEnumerable

A LINQ Query

C#

VB

LINQ Operators

• Restriction - Where• Projection - Select, SelectMany• Partitioning - Take, Skip, TakeWhile, SkipWhile• Ordering - OrderBy, OrderByDescending, ThenBy,

ThenByDecending, Reverse• Grouping - GroupBy• Set - Distinct, Union, Intersect, Except• Conversion – ToArray, ToDictionary, ToList, OfType

LINQ Operators

• Element – First, FirstOrDefault, ElementAt• Generation – Range,Repeat• Quantifiers – Any, All• Aggregate - Count, Sum, Min, Max, Average, Fold• Miscellaneous - Concat, EqualAll• Custom Sequence - Combine• Query Execution - Deferred, Immediate, Query Reuse

Typed Results using LINQ

LINQ and Anonymous Types

Pros of Type inference Make Code Simpler

Used for creating Anonymous types Iterate over IEnumerable<T> results where T is a projected

anonymous type Used in LINQ expressions

LINQ with Lambda Expressions Anonymous methods required parameter type to be

explicitly stated.

Lambda expressions permit parameter types to be omitted and allow them to be inferred based on usage.

Explicit type declaration is also allowed

Anonymous Methods

Lambda Expressions in VB

Lambda expression is an Inline function that you can pass to something that takes the delegate

Func type – Allows 4 arguments as leading generic parameters and 1 last generic parameter as return type

Evolution of LINQ

Comparison of LINQ and SQL Query

Projection

Filtering

Filtering

Sub Query

Joins

Cross Join

Inner Join

Joins

Outer Join

Set Operators

Set Operators

Aggregate Operations

LINQ Query Samples

101 LINQ C# Samples http://msdn.microsoft.com/en-us/vcsharp/aa336746.aspx

101 LINQ VB Samples http://msdn.microsoft.com/en-us/vbasic/bb688088.aspx

DLINQ Query expressions against Relational data Data Context is the conduit to retrieve data from database

and submit changes back LINQ to SQL ORM

Deferred Execution

Immediate Execution

DLINQ

XLINQQuery expressions against XML

XLINQ API

XAttribute XNode

XCharacterNode

XCData

XComment XContainer XDeclaration

XDocument

XDocumentType

XElement

XName

XProcessingInstruction

XText(internal)

Pros of LINQ• Avoids dynamic creation of queries hardcoded as strings

inside Code • Full type safety • Gives more power to manipulate data. Big advantage

over datasets. • Extensibility and expression trees allow mostly

consistent querying of multiple sources • Common syntax for querying any data source -

Relational, XML or In memory datasets or .NET objects• Can be used against .NET 1.0 or .NET 2.0 objects • Able to Extend LINQ to support new classes and

technologies

Pros – LINQ (Continued) Ability to access Stored procedures and user defined

functions in Database Integrated to .NET framework and Accessible from any .NET

compliant language Data manipulation logic/code is written in the application Declarative approach makes queries easier to understand and

more compact Even in-process queries can be implemented in ways other

than LINQ to Objects - e.g. Parallel LINQ and my own Push LINQ framework. Very flexible.

Pros – LINQ (Continued) Fabulously useful for in-process queries, where it's easiest to

understand Wide range of operators provided by default, and others can

easily be added for LINQ to Objects Language features introduced primarily for LINQ are widely

applicable elsewhere Consistent Domain Modeling Hiding the mundane code Short learning curve Intelli-sense and Designer support in Visual Studio

Cons of LINQ Query expressions aren't understood well enough, and are

overused. Often simple method invocation is shorter and simpler.

Inevitable inconsistencies between provider - impedance mismatch is still present, which is reasonable but needs to be understood

There will always be some things you can do in SQL but not in LINQ

Without understanding what's going on, it's easy to write very inefficient code

It's hard to write a LINQ provider. It's a new way of thinking about data access for most

developers, and will need time for understanding to percolate

Cons of LINQ (Continued) Some operators are "missing", particularly the equivalents of

OrderBy for things other than ordering - e.g. finding the item with the maximum value of a property

Deferred execution and streaming are poorly understood (but improving)

Debugging can be very tricky due to deferred execution and streaming

Data manipulation logic/code is written in the application. Cannot change logic without recompiling (Unlike Stored procedures)

Problem of viewing Execution plan and optimizing query

Embedded XML

Embedded XML in VB VB 9.0 provides deep support for XLINQ through XML literals

and late binding over XML. XML Literals allow straight XML to be embedded into the

source code. XML has become the first class citizen in Vb.NET.

Embedded XML in VBThe XML API helps us constructing the XML as follows

The compiler knows to use late binding over XML when the target expression is of type, or collection of, XElement, XDocument, or XAttribute.

Embedded XML in VB

The XML Support together with LINQ makes it possible to dynamically query and generate an XML.

Expression Trees

What are Expression Trees

A form of Data structure Represent Language level code in form of data Data is stored in Tree shaped structure Exposes parts of an expression by delineating code into data Each node in tree is an expression

Expression Tree Graph

Expression Trees

Higher level representation of query expressions which permit lambda expressions to be represented as data (expression trees) instead of as code (delegates).

C#

VB

Building Expression trees

Creating an expression

Initialize the Members

Building Expression trees

Form an expression

Execute an expression

Expression Tree Visualizer

Uses of Expression Trees• Play main role in LINQ to SQL• LINQ to SQL queries returns objects of type IQueryable<T>

• LINQ to SQL queries are not executed in C# program; Translated to SQL, sent across wire and executed in Database server

• Code found in a query expression has to be translated into a SQL query

• Easier to translate a data structure into SQL than executable code• Queries that return IEnumerable<T> do not use expression trees

(LINQ to Objects)

C# 4.0 and VB 10.0 (VS2010)

C# 4.0 VB 10.0

Dynamic lookupOptional and Named ParametersGeneric Co variance and Contra varianceImproved COM interoperabilityNo PIAParallel Programming, PLINQ

Dynamic Type

Generic Co variance and Contra varianceImproved COM interoperabilityNo PIAParallel Programming, PLINQAnonymous DelegatesImplicit Line continuationAuto Implemented PropertiesCollection InitialisersArray literalsNullable Optional Parameters