C# 3.0 Language Innovations

C# 3.0 Language Innovations
Query
var CommonWords = expressions
from w in wordOccurances
where w.Count > 2
Local variable select new { f.Name, w.Word, W.Count };
type inference

Lambda
expressions
var CommonWords =
wordOccurances
.Where(w => w.Count > 2)
.Select(w => new {f.Name, w.Word, W.Count });
Extension
methods Anonymous Object
types initializers
1

Lambda Expressions
public delegate bool Predicate<T>(T obj);

public class List<T>
{ Statement
public List<T> FindAll(Predicate<T> test) { … } context
Explicitly
… typed
} Implicitly
List<Customer> customers = typed
GetCustomerList();
List<Customer> x = customers.FindAll( Expression
delegate(Customer c) { return c.State == "WA"; } context
);

List<Customer> x = customers.FindAll(c => c.State == "WA");

2

Lambda Expressions
public delegate T Func<T>();
public delegate T Func<A0, T>(A0 arg0);
public delegate T Func<A0, A1, T>(A0 arg0, A1
arg1);
…
Func<Customer, bool> test = c => c.State == "WA";

double factor = 2.0;
Func<double, double> f = x => x * factor;

Func<int, int, int> f = (x, y) => x * y;

Func<int, int, int> comparer =
(int x, int y) => {
if (x > y) return 1;
if (x < y) return -1;
return 0;
};
3

Queries Through APIs
Query operators
are just methods
public class List<T>
{
public List<T> Where(Func<T, bool> predicate) { … }
public List<S> Select<S>(Func<T, S> selector) { … }
…
} Methods compose
to form queries
List<Customer> customers = GetCustomerList();

List<string> contacts =
customers.Where(c => c.State == "WA").Select(c =>
c.Name);
But what about
other types? Declare operators
in all collections? Type inference
figures out <S>
What about
arrays?

4

Queries Through APIs
Query operators
are static methods
public static class Sequence
{
public static IEnumerable<T> Where<T>(IEnumerable<T> source,
Func<T, bool> predicate) { … }

public static IEnumerable<S> Select<T, S>(IEnumerable<T> source,
Func<T, S> selector) { … }
…
} Huh?
Customer[] customers = GetCustomerArray();

IEnumerable<string> contacts = Sequence.Select(
Sequence.Where(customers, c => c.State == "WA"),
c => c.Name);

Want methods on
IEnumerable<T>

5

Extension Methods
class Customer { public string Name; }

Customer[ ] c = new Customer[1];

c._

Huh ?!!?!

6

Extension Methods
Extension
namespace System.Query methods
{
public static class Sequence
{
public static IEnumerable<T> Where<T>(this IEnumerable<T> source,
Func<T, bool> predicate) { … }

public static IEnumerable<S> Select<T, S>(this IEnumerable<T>
source, obj.Foo(x, y)
Func<T, S> selector) { … } Brings 
… extensions into XXX.Foo(obj, x, y)
} scope
} using System.Query;

IEnumerable<string> contacts =
customers.Where(c => c.State == "WA").Select(c =>
c.Name);

IntelliSense!

7

Extension Methods

public static class MyExtensions
{
public static IEnumerable<T> Where<T>(
this IEnumerable<T> source,
Func<T, bool> predicate)
{
foreach (T item in source)
if (predicate(item))
yield return item;
}
}

8

Extension Methods
Method is named
‘Where’

public static class MyExtensions
{
{
yield return item;
}
}

9

Extension Methods
Method is named
‘Where’

public static class MyExtensions Method extends
{ objects of type
IEnumerable<T>
{
yield return item;
}
}

10

Extension Methods
Method is named
‘Where’

{ objects of type
IEnumerable<T>
{
yield return item; Implementation
}
}

11

Extension Methods
Method is named
‘Where’

{ objects of type
IEnumerable<T>
Signature of the
{ predicate parameter
}
}

12

Extension Methods
Method is named
‘Where’

{ objects of type
IEnumerable<T>
Signature of the
}
} string[] names = { "Burke", "Connor", "Frank“ };
IEnumerable<string> expr = MyExtensions.Where(names,
s => s.Length < 6);
13

Extension Methods
Method is named
‘Where’
[System.Runtime.CompilerServices.Extension]
{ objects of type
IEnumerable<T>
Signature of the
}
} string[] names = { "Burke", "Connor", "Frank“ };
IEnumerable<string> expr = names.Where(names,
s => s.Length < 6);
14

Anonymous Types
public class Customer
{
public string Name;
public Address Address; public class Contact
public string Phone; { class ???
public List<Order> Orders; public{string Name;
… public string Phone; Name;
public string
} } public string Phone;
Customer c = GetCustomer(…); }
Contact x = new Contact { Name = c.Name, Phone = c.Phone };

Customer c = GetCustomer(…);
var x = new { Name = c.Name, Phone = c.Phone };

Projection style
Customer c = GetCustomer(…); initializer
var x = new { c.Name, c.Phone };

15

Anonymous Types
var contacts =
from c in customers
where c.State == "WA"
select new { c.Name, c.Phone }; class ???
{
IEnumerable<???> public string Name;
public string Phone;
}
var contacts =
customers.
.Where(c => c.State == "WA“)
.Select(c => new { c.Name, c.Phone });
???

foreach (var c in contacts) {
Console.WriteLine(c.Name);
Console.WriteLine(c.Phone);
}

16

Object Initializers
public class Point
{
private int x, y;

public int X { get { return x; } set { x = value; } } Field or property
public int Y { get { return y; } set { y = value; } } assignments
}

Point a = new Point { X = 0, Y = 1 };

Point a = new Point();
a.X = 0;
a.Y = 1;

17

Object Initializers
Embedded
public class Rectangle objects
{
private Point p1 = new Point();
private Point p2 = new Point(); Read-only
properties
public Point P1 { get { return p1; } }
public Point P2 { get { return p2; } }
}
Rectangle r = new Rectangle {
P1 = { X = 0, Y = 1 },
P2 = { X = 2, Y = 3 } No “new Point”
};

Rectangle r = new Rectangle();
r.P1.X = 0;
r.P1.Y = 1;
r.P2.X = 2;
r.P2.Y = 3;

18

Collection Initializers
Must implement
ICollection<T>

List<int> powers = new List<int> { 1, 10, 100, 1000,
10000 };
List<int> powers = new List<int>();
powers.Add(1);
powers.Add(10);
powers.Add(100);
powers.Add(1000);
powers.Add(10000);

19

Collection Initializers
public class Contact
{
private string name;
private List<string> phoneNumbers = new List<string>();

public string Name { get { return name; } set { name = value; } }
public List<string> PhoneNumbers { get { return phoneNumbers; } }
}
List<Contact> contacts = new List<Contact> {
new Contact {
Name = "Chris Smith",
PhoneNumbers = { "206-555-0101", "425-882-8080" }
},
new Contact {
Name = "Bob Harris",
PhoneNumbers = { "650-555-0199" }
}
};

20

Local Variable Type Inference
int i = 5;
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary<int,Order> orders = new Dictionary<int,Order>();

var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary<int,Order>();

“var” means same
type as initializer

21

Expression Trees
public class Northwind: DataContext
{
public Table<Customer> Customers;
public Table<Order> Orders; How does this
… get remoted?
}
Northwind db = new Northwind(…);
var query = from c in db.Customers where c.State == "WA" select c;

Northwind db = new Northwind(…); Method asks for
var query = db.Customers.Where(c => c.State == expression tree
"WA");
public class Table<T>: IEnumerable<T>
{
public Table<T> Where(Expression<Func<T, bool>> predicate);
…
}
System.Expressions.
Expression<T>
22

Expression Trees
Code as Data
Func<Customer, bool> test = c => c.State == "WA";

Expression<Func<Customer, bool>> test = c => c.State == "WA";

ParameterExpression c =
Expression.Parameter(typeof(Customer), "c");
Expression expr =
Expression.EQ(
Expression.Property(c,
typeof(Customer).GetProperty("State")),
Expression.Constant("WA")
);
Expression<Func<Customer, bool>> test =
Expression.Lambda<Func<Customer, bool>>(expr, c);

23

Query Expressions
Language integrated query syntax

Starts with
from Zero or more
from or where
from id in source
{ from id in source | where condition } Optional
[ orderby ordering, ordering, … ] orderby
select expr | group expr by key
[ into id query ] Ends with select
Optional into or group by
continuation

24

Query Expressions
Queries translate to method invocations
Where, Select, SelectMany, OrderBy, GroupBy

from c in customers
where c.State == "WA"
select new { c.Name, c.Phone };

customers
.Where(c => c.State == "WA")
.Select(c => new { c.Name, c.Phone });

25

C# 3.0 Language Innovations
Lambda expressions c => c.Name

Extension methods static void Dump(this object o);

Local variable type inference var x = 5;

Object initializers new Point { x = 1, y = 2 }

Anonymous types new { c.Name,
c.Phone }
Query expressions
from … where …
Expression trees select

Expression<T>
26

C# 3.0 Language Innovations

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to C# 3.0 Language Innovations (20)

More from Shahriar Hyder (8)

Recently uploaded (20)

C# 3.0 Language Innovations