this site is individual site for ueh students of information management faculty this site provides some students resources of it courses such as computer network data structure and algorithm enterprise resource planning

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (438.53 KB, 45 trang )

(1)<div class='page_container' data-page=1>

Chapter 15. Introduction

</div>
(2)<div class='page_container' data-page=2>

Objectives

</div>
(3)<div class='page_container' data-page=3>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

</div>
(4)<div class='page_container' data-page=4>

15.1 The Role of LINQ



The LINQ API is an attempt to provide a consistent,

symmetrical manner in which programmers can obtain

and manipulate “data” in the broad sense of the term



LINQ Expressions Are Strongly Typed and Extendable



The Core LINQ Assemblies

 System.Core.dll

 System.Data.Linq.dll

 System.Data.DataSetExtensions.dll

</div>
(5)<div class='page_container' data-page=5>

The Role of LINQ



Advantages of LINQ

 For now:

 Dynamically-created string queries

 Doesn't provide compile-time checking

 Native code and non-native code is mixed

 With LINQ

 Static typing

 Compile-time syntax checking

</div>
(6)<div class='page_container' data-page=6>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

</div>
(7)<div class='page_container' data-page=7>

15.2 A First Look at LINQ Query

Expressions



LINQ and Implicitly Typed Local Variables

 Type of the variable induced from expression

 Must include initializer
 Can’t be null. Why not?

 What happens if “var” is a class in scope?
 Works in for loops

var i = 5;

var s = "Hello";

var d = 1.0;

</div>
(8)<div class='page_container' data-page=8>

LINQ Query Expressions



LINQ and Extension Methods

 The Problem: How to add a method to a type you don’t control

and can’t subtype?

 Example: How to add Standard Query Operators to

IEnumerable<T>, without deriving a new interface?

 Solution: Extension methods aren’t really members of the target

type, but the syntax makes them look that way

</div>
(9)<div class='page_container' data-page=9>

LINQ Query Expressions



LINQ and Extension Methods

 Not for properties, events, operators

 Currently under consideration

 Equivalent to calling the static method

 Difference from actually extending the class?

 How could we use this for Polynomials?

 Disadvantages?

 Implicitness

</div>
(10)<div class='page_container' data-page=10>

LINQ Query Expressions



Creating Extension Methods

 Define a Static Class

 Define a static method whose first argument is an object of type
T

 [System.Runtime.CompilerServices.Extension] attribute on first

parameter tells CLR the method is an Extension

 C# binds the attribute to keyword “this”

 Create a T object, and call the method as if it were a member of
the object

</div>
(11)<div class='page_container' data-page=11>

Replacing LINQ Extension Methods

 Extension Methods have lower priority of resolution than type
members

 So if a type has a member with same signature as a LINQ

extension method, the type’s member will be called, and there is
no ambiguity



This is how DLINQ and XLINQ replace the default LINQ

implementations of the Standard Query Operators

class MyList : IEnumerable<int> {

public IEnumerable<int> Where(

Func<int,bool> filter) {

// LINQ queries on MyList objects will call this
// instead of Sequence.Where()

</div>
(12)<div class='page_container' data-page=12>

Lambda Expressions

 Lambda Expressions

 Generalized function syntax

  x . x + 1

 in C# 3.0, have x => x + 1

 From anonymous delegate syntax:

 delegate(int x) { return x + 1;}

 Can have implicitly typed variables

 Can have more than one variable

 Can have expression or statement body

</div>
(13)<div class='page_container' data-page=13>

 Lambda expressions

 Can be converted to delegate type

 if parameters and body match

 Participate in type inference

 If expression body, get expression trees

Lambda Expression

delegate R Func<A,R>(A arg);

Func<int,int> f1 = x => x + 1;

Func<int,double> f2 = x => x + 1;

</div>
(14)<div class='page_container' data-page=14>

Lambda Expression

 Lambda expressions

 Type inference

 If call Select(customers, c => c.Name);

 T, S mapped to appropriate types

public static IEnumerable<S> Select<T,S>(

this IEnumerable<T> source,

Func<T,S> selector)

{

foreach (T element in source)

yield return selector(element);

</div>
(15)<div class='page_container' data-page=15>

The Role of Differed Execution



LINQ query expressions are not actually evaluated

until you iterate over their contents



Apply the same LINQ query multiple times to the

</div>
(16)<div class='page_container' data-page=16>

The Role of Immediate Execution



To evaluate a LINQ expression from outside the confines

of foreach logic, you are able to call any number of

extension methods defined by the Enumerable type



Extension methods:ToArray<T>,

ToDictionary<TSource,TKey>(), and ToList<T>()



Capture a LINQ query result set in a strongly typed

</div>
(17)<div class='page_container' data-page=17>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

</div>
(18)<div class='page_container' data-page=18>

15.3 LINQ and Generic Collections



LINQ query expressions can also manipulate data within

members of the System.Collections.Generic namespace,

such as the List<T> type

class Car

{

public string PetName = string.Empty;

public string Color = string.Empty;

public int Speed;

public string Make = string.Empty;
}

</div>
(19)<div class='page_container' data-page=19>

Classes



System.Collections.Generic classes

 List<ItemType>

 Dictionary<K,V>

 Stack<ItemType>

 Queue<ItemType>



System.Collections.Generic interfaces

 IList<ItemType>

 IDictionary<K,V>

 ICollection<ItemType>

 IEnumerable<ItemType>

 IEnumerator<ItemType>

</div>
(20)<div class='page_container' data-page=20>

Applying a LINQ Expression



grabbing items from the List<T> where the Speed

property is greater than 55

static void GetFastCars(List<Car> myCars)
{

// Create a query expression.

var fastCars = from c in myCars where c.Speed > 55 select c;

foreach (var car in fastCars)
{

Console.WriteLine("{0} is going too fast!", car.PetName);

</div>
(21)<div class='page_container' data-page=21>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

</div>
(22)<div class='page_container' data-page=22>

15.4 LINQ and Nongeneric Collections



It is possible to iterate over data contained within

nongeneric collections using the generic

Enumerable.OfType<T>() method

// Extract the ints from the ArrayList.

ArrayList myStuff = new ArrayList();

myStuff.AddRange(new object[] { 10, 400, 8, false, new Car(),

"string data" });

IEnumerable<int> myInts = myStuff.OfType<int>();

// Prints out 10, 400, and 8.

</div>
(23)<div class='page_container' data-page=23>

Nongeneric Collections



Use the previously defined Car type and import the

System.Collections namespace

static void Main(string[] args)

{

Console.WriteLine("***** LINQ over ArrayList *****\n");

// Here is a nongeneric collection of cars.
ArrayList myCars = new ArrayList() {

new Car{ PetName = "Henry", Color = "Silver", Speed = 100, Make

= "BMW"},

new Car{ PetName = "Daisy", Color = "Tan", Speed = 90, Make =

"BMW"},

new Car{ PetName = "Mary", Color = "Black", Speed = 55, Make =

"VW"},

new Car{ PetName = "Clunker", Color = "Rust", Speed = 5, Make =

"Yugo"},

</div>
(24)<div class='page_container' data-page=24>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.5 The Internal Representation of LINQ Query Operators

</div>
(25)<div class='page_container' data-page=25>

15.5 The Internal Representation of LINQ

Query Operators



Introduced to the process of building query expressions

using various C# query operators (such as from, in,

where, orderby, and select)



C# compiler actually translates these tokens into calls on

various methods of the System.Linq.Enumerable type



Many methods require a generic delegate of type

</div>
(26)<div class='page_container' data-page=26>

Query Expressions

 Adds querying to language

 Important for interaction with DB

 Built-in data structures

 Leave query planning to data structure designer

 Implemented using above functionality

 Anonymous types and variables useful

</div>
(27)<div class='page_container' data-page=27>

Query Expressions

 As with collections:

 not an interface

 just need to implement the methods

 necessary for backwards compatibility

 methods may be implemented by extension

 Methods named as above

 Any class that implements pattern can be accessed via the new

</div>
(28)<div class='page_container' data-page=28>

Building Query Expressions with Query

Operators



Building LINQ expressions using various query operators

(from, in, where, orderby, etc.) is the most common and

most straightforward approach

static void QueryStringWithOperators()
{

Console.WriteLine("***** Using Query Operators *****");

string[] currentVideoGames = {"Morrowind", "BioShock",
"Half Life 2: Episode 1", "The Darkness",

"Daxter", "System Shock 2"};
// Build a query expression using query operators.

var subset = from g in currentVideoGames

where g.Length > 6 orderby g select g;

</div>
(29)<div class='page_container' data-page=29>

Building Query Expressions Using the

Enumerable Type and Lambdas

 Building a LINQ query expression using the methods of the

Enumerable type directly is much more verbose than making use of
the C# query operators

static void QueryStringsWithEnumerableAndLambdas()
{

string[] currentVideoGames = {"Morrowind", "BioShock",

"Half Life 2: Episode 1", "The Darkness",

"Daxter", "System Shock 2"};

// Build a query expression using extension methods
// granted to the Array via the Enumerable type.

var subset = currentVideoGames.Where(game => game.Length > 6)

.OrderBy(game => game).Select(game => game);

// Print out the results.

foreach (var game in subset)

Console.WriteLine("Item: {0}", game);

</div>
(30)<div class='page_container' data-page=30>

Building Query Expressions Using the

Enumerable Type and Anonymous Methods

static void QueryStringsWithAnonymousMethods()

{

Console.WriteLine("***** Using Anonymous Methods *****");

string[] currentVideoGames = {"Morrowind", "BioShock",
"Half Life 2: Episode 1", "The Darkness",

"Daxter", "System Shock 2"};

// Build the necessary Func<> delegates using anonymous methods.

Func<string, bool> searchFilter =

delegate(string game) { return game.Length > 6; };

Func<string, string> itemToProcess = delegate(string s) {

return s; };

// Pass the delegates into the methods of Enumerable.

var subset = currentVideoGames.Where(searchFilter)

.OrderBy(itemToProcess).Select(itemToProcess);

</div>
(31)<div class='page_container' data-page=31>

Building Query Expressions Using the

Enumerable Type and Raw Delegates

class VeryComplexQueryExpression

{

public static void QueryStringsWithRawDelegates()
{

Console.WriteLine("***** Using Raw Delegates *****");

string[] currentVideoGames = {"Morrowind", "BioShock",

"Half Life 2: Episode 1", "The Darkness",

"Daxter", "System Shock 2"};

// Build the necessary Func<> delegates using anonymous methods.

Func<string, bool> searchFilter = new Func<string, bool>(Filter);

Func<string, string> itemToProcess = new
Func<string,string>(ProcessItem);

// Pass the delegates into the methods of Enumerable.
var subset = currentVideoGames

.Where(searchFilter).OrderBy(itemToProcess).Select(itemToProcess);

// Print out the results.

foreach (var game in subset)

Console.WriteLine("Item: {0}", game);

Console.WriteLine();
}

</div>
(32)<div class='page_container' data-page=32>

Internal Representation



Query expressions are created using various C# query

operators



Query operators are simply shorthand notations for invoking

extension methods defined by the System.Linq.Enumerable

type



Many methods of Enumerable require delegates (Func<> in

particular) as parameters



Under C# 2008, any method requiring a delegate parameter

can instead be passed a lambda expression



Lambda expressions are simply anonymous methods in

</div>
(33)<div class='page_container' data-page=33>

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.5 The Internal Representation of LINQ Query Operators

</div>
(34)<div class='page_container' data-page=34>

15.6 Investigating the C# LINQ Query

Operators

Operators Meaning in Life

from, in

Used to define the backbone for any LINQ expression,
which allows you to extract a subset of data from a
fitting container.

where Used to define a restriction for which items to extract
from a container

select Used to select a sequence from the container

join, on, equals, into

</div>
(35)<div class='page_container' data-page=35>

Building a New Test Project



Create a new Console Application named

FunWithLinqExpressions



Next, define a trivial Car type



Populate an array with the following Car objects within

</div>
(36)<div class='page_container' data-page=36>

class Car

{

public string PetName = string.Empty;

public string Color = string.Empty;

public int Speed;

public string Make = string.Empty;

public override string ToString()
{

return string.Format("Make={0}, Color={1}, Speed={2}, PetName={3}",

Make, Color, Speed, PetName);
}

}

static void Main(string[] args)
{

Console.WriteLine("***** Fun with Query Expressions *****\n");

// This array will be the basis of our testing...

Car[] myCars = new [] {

new Car{ PetName = "Henry", Color = "Silver", Speed = 100, Make = "BMW"},

new Car{ PetName = "Daisy", Color = "Tan", Speed = 90, Make = "BMW"},

new Car{ PetName = "Mary", Color = "Black", Speed = 55, Make = "VW"},

new Car{ PetName = "Clunker", Color = "Rust", Speed = 5, Make = "Yugo"},

new Car{ PetName = "Hank", Color = "Tan", Speed = 0, Make = "Ford"},

new Car{ PetName = "Sven", Color = "White", Speed = 90, Make = "Ford"},

new Car{ PetName = "Mary", Color = "Black", Speed = 55, Make = "VW"},

new Car{ PetName = "Zippy", Color = "Yellow", Speed = 55, Make = "VW"},

new Car{ PetName = "Melvin", Color = "White", Speed = 43, Make = "Ford"}
};

</div>
(37)<div class='page_container' data-page=37>

Basic Selection Syntax



Ordering of the operators is critical



var result = from item in container select item;

static void BasicSelection(Car[] myCars)
{

// Get everything.

Console.WriteLine("All cars:");

var allCars = from c in myCars select c;

foreach (var c in allCars)
{

Console.WriteLine(c.ToString());
}

</div>
(38)<div class='page_container' data-page=38>

Obtaining Subsets of Data



To obtain a specific subset from a container, use the

where operator



var result = from item in container where Boolean

expression select item;

static void GetSubsets(Car[] myCars)
{

// Now get only the BMWs.

var onlyBMWs = from c in myCars where c.Make ==

"BMW" select c;

</div>
(39)<div class='page_container' data-page=39>

Projecting New Data Types



The compiler defines a only property and a

read-only backing field for each specified name



Project new forms of data from an existing data source

var makesColors = from c in myCars select new {c.Make,

c.Color};

foreach (var o in makesColors)
{

</div>
(40)<div class='page_container' data-page=40>

Reversing Result Sets



Using the generic Reverse<T>() method of the

Enumerable type

static void ReversedSelection(Car[] myCars)
{

// Get everything in reverse.

Console.WriteLine("All cars in reverse:");

var subset = (from c in myCars select 
c).Reverse<Car>();

foreach (Car c in subset)
{

Console.WriteLine("{0} is going {1} 
MPH", c.PetName, c.Speed);

</div>
(41)<div class='page_container' data-page=41>

Sorting Expressions

 A query expression can take an orderby operator to sort items in the subset by a
specific value

 To view the results in a descending order, simply include the descending operator

</div>
(42)<div class='page_container' data-page=42>

Example

1. static void OrderedResults(Car[] myCars)

2. {

3. // Order all the cars by PetName.

4. var subset = from c in myCars orderby c.PetName select c;
5. Console.WriteLine("Ordered by PetName:");

6. foreach (Car c insubset)

7. {

8. Console.WriteLine(c.ToString());

9. }

10. // Now find the cars that are going less than 55 mph,
11. // and order by descending PetName

12. subset = from c in myCars

13. where c.Speed > 55 orderby c.PetName descending select c;

14. Console.WriteLine("\nCars going faster than 55, ordered by PetName:");
15. foreach (Car c insubset)

16. {

17. Console.WriteLine(c.ToString());

18. }

</div>
(43)<div class='page_container' data-page=43>

Finding Differences

 obtaining a result set that determines the differences between 
two IEnumerable<T> compatible containers

static void GetDiff()
{

List<string> myCars = new List<String>
{ "Yugo", "Aztec", "BMW"};

List<string> yourCars = new List<String>
{ "BMW", "Saab", "Aztec" };

var carDiff =(from c in myCars select c)

.Except(from c2 in yourCars select c2);

Console.WriteLine("Here is what you don't have, but I do:");

foreach (string s in carDiff)

Console.WriteLine(s); // Prints Yugo.

</div>
(44)<div class='page_container' data-page=44>

Summary



LINQ is a set of related technologies that attempts to

provide a single, symmetrical manner to interact with

diverse forms of data



LINQ query expressions can return any number of result

sets, it is common to make use of the var keyword to

represent the underlying data type



LINQ query operators are simply shorthand notations for

</div>
(45)<div class='page_container' data-page=45>

References



Books:

</div>

this site is individual site for ueh students of information management faculty this site provides some students resources of it courses such as computer network data structure and algorithm enterprise resource planning

<b>Chapter 15. Introduction</b>

Objectives

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.1 The Role of LINQ

The LINQ API is an attempt to provide a consistent,

symmetrical manner in which programmers can obtain

and manipulate “data” in the broad sense of the term

LINQ Expressions Are Strongly Typed and Extendable

The Core LINQ Assemblies

The Role of LINQ

Advantages of LINQ

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.2 A First Look at LINQ Query

Expressions

LINQ and Implicitly Typed Local Variables

LINQ Query Expressions

LINQ and Extension Methods

LINQ Query Expressions

LINQ and Extension Methods

LINQ Query Expressions

Creating Extension Methods

Replacing LINQ Extension Methods

This is how DLINQ and XLINQ replace the default LINQ

implementations of the Standard Query Operators

Lambda Expressions

Lambda Expression

Lambda Expression

The Role of Differed Execution

LINQ query expressions are not actually evaluated

until you iterate over their contents

Apply the same LINQ query multiple times to the

The Role of Immediate Execution

To evaluate a LINQ expression from outside the confines

of foreach logic, you are able to call any number of

extension methods defined by the Enumerable type

Extension methods:ToArray<T>,

ToDictionary<TSource,TKey>(), and ToList<T>()

Capture a LINQ query result set in a strongly typed

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.3 LINQ and Generic Collections

LINQ query expressions can also manipulate data within

members of the System.Collections.Generic namespace,

such as the List<T> type

Classes

System.Collections.Generic classes

System.Collections.Generic interfaces

Applying a LINQ Expression

grabbing items from the List<T> where the Speed

property is greater than 55

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.4 LINQ and Nongeneric Collections

It is possible to iterate over data contained within

nongeneric collections using the generic

Enumerable.OfType<T>() method

Nongeneric Collections

Use the previously defined Car type and import the

System.Collections namespace

Roadmap

15.1 Understanding the Role of LINQ

15.2 A First Look at LINQ Query Expressions

15.3 LINQ and Generic Collections

15.4 LINQ and Nongeneric Collections

15.5 The Internal Representation of LINQ Query Operators