C # Getting Started with LINQ

C # Getting Started with LINQ
Introduction to LINQ

Language-Integrated Query (LINQ) is an innovative feature introduced in Visual Studio 2008 and the. NET Framework version 3.5.

Traditionally, queries for data are represented as simple strings, without compile-time type checking or IntelliSense support. In addition, you must learn a different query language for each of the following data sources: SQL database, XML document, various WEB services, and so on. With LINQ, you can write queries against a strongly typed collection of objects using language keywords and familiar operators.

C # Getting Started with LINQ (top)

In Visual Studio, you can write LINQ queries for the following data sources: SQL Server databases, XML documents, ADO datasets, and any collection of objects that support the IEnumerable or generic ienumerable<t> interface 。

Usage requirements: Project ≥.net Framework 3.5.

I. INTRODUCTION of LINQ Queries

A query is an expression that retrieves data from a data source. Over time, people have developed different languages for various data sources, for example, SQL for relational databases and XQuery for XML. As a result, developers have to learn a new query language for each data source or data format that they must support.

LINQ simplifies this situation by providing a consistent model that uses data across data sources and data formats. In a LINQ query, objects are always used. You can use the same encoding pattern to query and transform data in XML documents, SQL databases, ADO datasets,. NET collections, and any other format for which the LINQ provider is available.

1.1 Three parts of a query operation

Operation Trilogy: ① fetch data source ② Create query ③ Execute Query

Internal class Program

{

private static void Main (string[] args)

{

1. Get the data source

var nums = new Int[7] {0, 1, 2, 3, 4, 5, 6};

2. Create a query

var numquery =

From Num in Nums

WHERE (num% 2) = = 0

Select num;

3. Execute the Query

foreach (Var num in numquery)

{

Console.WriteLine ("{0}", num);

}

}

}

C # Getting Started with LINQ (top)

Shows the full query operation. In LINQ, the execution of a query is very different from the query itself; in other words, the query itself refers to creating only query variables and not retrieving any data.

C # Getting Started with LINQ (top)

1.2 Data sources

In the previous example, because the data source is an array, it implicitly supports the generic ienumerable<t> interface. Types that support ienumerable<t> or derived interfaces, such as generic iqueryable<t>, are called queryable types.

A queryable type can be used as a LINQ data source without modification or special processing. If the source data is not yet present in memory as a queryable type, the LINQ provider must represent the source data in this manner. For example, LINQ to XML loads an XML document into a queryable XElement type:

To create a data source from XML

Using System.Xml.Linq;

var contacts = Xelement.load (@ "C:\xxx.xml");

In LINQ to SQL, you first need to create an object-relational mapping. Queries are written against these objects and then the communication to the database is handled by LINQ to SQL at run time.

var db = new Northwnd (@ "C:\northwnd.mdf");

Find a customer in London

var custquery= from Cust in db. Customers

Where Cust. City = = "London"

Select Cust;

Customers represents a specific table in a database

1.3 Queries

The query specifies the information to retrieve from the data source. Queries can also specify how to sort, group, and structure the information before returning it. The query is stored in a query variable and initialized with a query expression.

The query in the previous example is to return all the even numbers from an array of integers. The query expression consists of three clauses: from, where, and select. (If you are familiar with SQL, you will notice that the order of these clauses is the opposite of the order in SQL.) The FROM clause specifies the data source, where clause specifies that the filter is applied, and the SELECT clause specifies the type of element returned. It is important to note that in LINQ, the query variable itself does nothing and returns no data. It simply stores the information necessary to generate the results at a later time when the query is executed.

1.4 Query execution

1. Deferred execution

As mentioned earlier, the query variable itself simply stores the query command. The actual query execution is deferred until the query variable is cycled through the foreach statement. This concept is called "deferred execution."

2. Force immediate Execution

Queries that perform aggregate functions on a series of source elements must first iterate through the elements. Count, Max, Average, and first belong to this type of query. Because the query itself must use foreach to return results, these queries do not use explicit foreach statements when they are executed. Also note that these types of queries return a single value instead of a IEnumerable collection.

var numbers = new Int[7] {0, 1, 2, 3, 4, 5, 6};

var evennumquery =

From Num in numbers

WHERE (num% 2) = = 0

Select num;

var evennumcount = Evennumquery.count ();

C # Getting Started with LINQ (top)

To force an immediate execution of arbitrary queries and to cache their results, you can call the Tolist<tsource> or Toarray<tsource> method.

var numQuery2 = (from num in numbers

WHERE (num% 2) = = 0

Select num). ToList ();

var numQuery3 = (from num in numbers

WHERE (num% 2) = = 0

Select num). ToArray ();

In addition, you can force a query by placing a foreach loop where it immediately follows the query expression. However, you can also cache all data in a single collection object by calling ToList or ToArray.

Second, the basic LINQ query operation

2.1 Get Data Source: from

In a LINQ query, the first step is to specify the data source. As in most programming languages, you must declare a variable before you can use it. In LINQ queries, the first use of the FROM clause is to introduce data sources and scope variables.

Queryallcustomers is the ienumerable<cutsomer> type

Data source (customers) and range variables (Cust)

var queryallcustomers = from Cust in Customers

Select Cust;

A range variable is similar to an iteration variable in a foreach loop, but in a query expression, the iteration does not actually occur. When you execute a query, the range variable is used as a reference to each successive element in customers. Because the compiler can infer the type of Cust, you do not have to explicitly specify this type.

2.2 Filtering: where

Perhaps the most common query operation is to apply a filter in the form of a Boolean expression. This filter causes the query to return only those elements whose expression result is true. Use the WHERE clause to generate the results. In effect, a filter specifies which elements are excluded from the source sequence.

var querylondoncustomers = from Cust in Customers

Where Cust. City = "London"

Select Cust;

You can use the familiar C # logic and (&&) and OR (| | operator to apply any number of filter expressions in the WHERE clause as needed.

Where Cust. City = "London" && Cust. Name = "Devon"

Where Cust. City = "London" | | Cust. Name = "Paris"

2.3 Reviews sorted By:

It is generally easy to sort the returned data. The ORDER BY clause causes the elements in the returned sequence to be sorted according to the default comparer for the type being sorted.

var querylondoncustomers = from Cust in Customers

Where Cust. City = "London"

Cust. Name Descending

Select Cust;

Because Name is a string, the default comparer performs an alphabetical sort from a to Z. To sort the results in reverse order (from Z to A), use the orderby...descending clause.

2.4 Group: Group

Using the group clause, you can group the results by the specified key.

var querylondoncustomers = from Cust in Customers

Group Cust by Cust. City;

foreach (Var querylondoncustomer in querylondoncustomers)

{

Console.WriteLine (Querylondoncustomer.key);

foreach (Var cust in Querylondoncustomer)

{

Console.WriteLine (Cust. Name);

}

}

You can specify that the results should be grouped by city so that all customers in London or Paris are in their respective groups.

In this case, Cust. City is the key.

When you end a query by using the group clause, the result takes the form of a list. Each element in the list is an object that has a key member and a list of elements grouped by the key. When iterating through queries that generate group sequences, you must use nested foreach loops. The outer loop is used to iterate through each group, and the inner loop is used to iterate through the members of each group.

If you must reference the results of a group operation, you can use the INTO keyword to create identifiers that can be queried further.

Custquery is ienumable<igrouping<string, customer>> type

var custquery = from Cust in Customers

Group Cust by Cust. City

Into CustGroup

where Custgroup.count () > 2

Custgroup.key

Select CustGroup;

The query here only returns those groups that contain more than two customers.

2.5 Joins: Join

Join operations create associations between sequences in the data source that do not have an explicit modeling. For example, you can perform a join to find all customers and resellers in the same location. In LINQ, a join clause is always run against a collection of objects rather than directly against a database table.

var innerjoinquery = from Cust in Customers

Join Dist in distributors on Cust. City equals Dist. City

Select New {CustomerName = cust. Name, Distributorname = Dist. Name};

In LINQ, a join clause is always run against a collection of objects rather than directly against a database table.

In LINQ, you do not have to use joins as frequently as in SQL, because foreign keys in LINQ are represented in the object model as properties that contain collections of items.

From order in customer.orders ...

2.6 Selection (projection): Select

The SELECT clause generates a query result and specifies the shape or type of each returned element.

For example, you can specify whether the result contains the entire Customer object, only one member, a subset of members, or a completely different result type based on a calculation or new object creation. When a SELECT clause generates something other than a copy of the source element, the operation is called projection.

Iii. using LINQ for data conversion

Language-Integrated Query (LINQ) is not only useful for retrieving data, but it is also a powerful data transformation tool. By using a LINQ query, you can use the source sequence as input and modify it in several ways to create a new output sequence. You can modify the sequence by sorting and grouping without having to modify the element itself. However, the most powerful feature of LINQ queries is the ability to create new types. This feature is implemented in the SELECT clause. For example, you can perform the following tasks:

3.1 Joining multiple inputs to an output sequence

Class Student

{

public string Name {get; set;}

public int Age {get; set;}

public string City {get; set;}

Public list<int> Scores {get; set;}

}

Class Teacher

{

public int Id {get; set;}

public string Name {get; set;}

public int Age {get; set;}

public string City {get; set;}

}

Two classes of students and teachers

Internal class Program

{

private static void Main (string[] args)

{

Create a First Data source

var students = new List<student> ()

{

New Student ()

{

Age = 23,

City = "Guangzhou",

Name = "Small C",

Scores = new List<int> () {85,88,83,97}

},

New Student ()

{

Age = 18,

City = "Guangxi",

Name = "Xiaoming",

Scores = new List<int> () {86,78,85,90}

},

New Student ()

{

Age = 33,

City = "Dream",

Name = "Small Three",

Scores = new List<int> () {86,68,73,97}

}

};

Create a second data source

var teachers = new List<teacher> ()

{

New Teacher ()

{

Age = 35,

City = "Dream",

Name = "Kiss-Doraemon"

},

New Teacher ()

{

Age = 28,

City = "Yunnan",

Name = "Little Red"

},

New Teacher ()

{

Age = 38,

City = "Henan",

Name = "Lili"

}

};

Create a query

var peopleindreams = (from student in students

where student. City = = "Dream"

Select Student. Name)

. Concat (from teacher in teachers

where teacher. City = = "Dream"

Select Teacher. Name);

Execute Query

foreach (var in peopleindreams)

{

Console.WriteLine (person);

}

Console.read ();

}

}

Manuscripts: Diligent Learning qkxue.net
Extended reading:
C # Getting Started with LINQ (top)
Http://qkxue.net/info/21835/nbsp-LINQ
C # Getting Started with LINQ (bottom)
Http://qkxue.net/info/21834/nbsp-LINQ

C # Getting Started with LINQ