Introduction to LINQ in c#
LINQ (Language Integrated Query) in the C# programming language is a collection of user-defined multiple class methods in a C# program. It provides a unified method for directly querying multiple types of class data sources (such as array data sequences, collection data types, database elements, XML file formats, etc.) in a declarative-style format within a C# program. It allows C# users to create SQL-like database software queries directly within the program source code, making the data query, retrieval, and manipulation process in existing programs much easier and shorter.
LINQ methods simplify the process of working with database query data by allowing C# programs to apply uniform syntax to multiple user-defined class data types. It injects, or integrates, the capability to query databases directly into the C# language. This improves the ability to read and maintain C# program source code.
Advanced Features of LINQ in C# Programming.
- Query Syntax and Method Syntax – LINQ queries in C# programs can be created in two main syntaxes: query syntax (similar to SQL syntax) and method syntax (similar to Fluent-style methods). You can use either.
- Deferred Execution – LINQ query data in C# programs are not executed when they are defined in the program. Rather, they are executed when the program output results are actually enumerated. This means that the LINQ database query will only be executed when the actual data is needed in the current program, which can improve database performance.
- Strongly Typed – LINQ queries used for database integration in C# programs are type-safe. This means that the C# program compiler ensures that you are querying the required program data in the proper order based on its data type.
- Extensibility – LINQ data queries in any C# program can be used or applied to a variety of data sources, such as array data types, collection data, XML data formats, databases (using Entity Framework or LINQ to SQL), and more. It can be extended if needed.
Basic Syntax of LINQ in C#.
LINQ Query Syntax in C#.
LINQ query syntax is similar to SQL database software syntax, and it uses reserved database keywords like from, where, select, group by, and so on, similar to SQL.
var output = from data in collection
where data.Condition
select data;
Method Query Syntax in C#.
In C# programs, the LINQ query integration method uses a simpler syntax, and database query retrieval is based on SQL keyword statements in LINQ extension methods such as Where(), Select(), OrderBy(), etc.
var output = collection.Where(data => data.Condition)
.Select(data => data.Property);
Querying LINQ to Objects data.
The most common use of LINQ methods in C# programs is to query data information from in-memory collections such as arrays, lists, and dictionaries in a database. Here’s an example of how the LINQ data connection method performs with these collections.
Example of using the LINQ connection method with the array data type.
using System;
using System.Linq;
public class program
{
public static void Main()
{
int[] integers = { 12, 13, 14, 17, 22, 27, 29, 32, 33, 35, 38, 41 };
// here we use LINQ Query Syntax method to get query data
var evenintegersQuery = from numeric in integers
where numerical % 2 == 0
select numeric;
// here we use LINQ Method Syntax to extract array data
var evenNumbersMethod = integers.Where(numeric => numeric % 2 == 0);
//here is the output results
Console.WriteLine(“Display Even numeric with query syntax.”);
foreach (var numeric in evenintegersQuery)
{
Console.WriteLine(numeric); // Result is – 12 14 22 32 38
}
Console.WriteLine(“Display even numeric with method syntax.”);
foreach (var numeric in evenNumbersMethod)
{
Console.WriteLine(numeric); // Result is – 12 14 22 32 38
}
}
}
Explain the LINQ connection method with the array data.
- Here, integers is an array data type collection of integer constants.
- where numeric % 2 == 0 filters and displays even numbers from the array collection.
- Here, the LINQ connection is performed using both query syntax and method syntax, and both methods yield the same result.
Common LINQ database connection query methods in C#.
Where – This SQL-based reserved keyword filters the database element data value content based on a statement condition and displays it in the console screen.
- var evenIntegers = Integers.Where(n => n % 2 == 0);
Select – This SQL-based reserved keyword displays each data element of a database statement query collection by projecting it into a new form.
- var squareIntegers = Integers.Select(n => n * n);
OrderBy / OrderByDescending – This SQL-based reserved keyword displays the database query elements sorted in increment or decrement order.
- var sortedIntegers = Integers.OrderBy(n => n);
- var descendingIntegers = Integers.OrderByDescending(n => n);
GroupBy – This displays SQL-based database element data by grouping it according to a particular key.
- var groupedByParity = Integers.GroupBy(n => n % 2 == 0);
Aggregate – Displays a single value output by applying an accumulator aggregate function to a database array or collection of data.
- var addtion = Integers.Aggregate((total, next) => total + next);
First / FirstOrDefault – This displays the first element in the database, or a default value output if no element is found.
- var firstEvenintegers = integers.First(n => n % 2 == 0);
- var firstEvenOrDefault = integers.FirstOrDefault(n => n % 2 == 0);
Distinct – This removes duplicate element data values from a group of array data type collections.
- var distinctIntegers = Integers.Distinct();
Any / All – This checks the group of array data to see if any or all elements satisfy the condition.
- var anyEven = Integers.Any(n => n % 2 == 0); // This checks whether an integer number is even or not in an expression.
- var allEven = Integers.All(n => n % 2 == 0); // This checks whether all integer numbers are even or not in an expression.
Example of a common LINQ database connection query.
using System;
using System.Linq;
using System.Collections.Generic;
public class Program
{
public static void Main()
{
List<int> Integers = new List<int>
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6
};
// here we apply Where sql clause – Even numbers
var evenIntegers = Integers.Where(n => n % 2 == 0);
// here we use Select sql clause – Square of numbers
var squareIntegers = Integers.Select(n => n * n);
// herwe we use OrderBy sql clause – Ascending order data arrangement
var sortedIntegers = Integers.OrderBy(n => n);
// here we OrderByDescending sql clause – Descending order data order arrangement
var descendingIntegers = Integers.OrderByDescending(n => n);
// GroupBy – Group by parity sql clause (Even/Odd)
var groupedByParity = Integers.GroupBy(n => n % 2 == 0);
// here we Aggregate – Sum of all integer numbers
var addition = Integers.Aggregate((total, next) => total + next);
// here we use First – First even number
var firstEvenIntegers = Integers.First(n => n % 2 == 0);
// here we FirstOrDefault – First even number or default
var firstEvenOrDefault = Integers.FirstOrDefault(n => n % 2 == 0);
// here we use Distinct – Remove duplicates value
var distinctIntegers = Integers.Distinct();
// here we use Any – Check if any even numbers exist
var anyEven = Integers.Any(n => n % 2 == 0);
// here All – Check if all numbers are even
var allEven = Integers.All(n => n % 2 == 0);
// method to Display all link query output
Console.WriteLine(“Original Integers:”);
Console.WriteLine(string.Join(“, “, Integers));
Console.WriteLine(“\n Even Integers:”);
Console.WriteLine(string.Join(“, “, evenIntegers));
Console.WriteLine(“\n Square Integers:”);
Console.WriteLine(string.Join(“, “, squareIntegers));
Console.WriteLine(“\n Sorted Integers (Ascending):”);
Console.WriteLine(string.Join(“, “, sortedIntegers));
Console.WriteLine(“\n Sorted Integers (Descending):”);
Console.WriteLine(string.Join(“, “, descendingIntegers));
Console.WriteLine(“\n Grouped By Parity:”);
foreach (var group in groupedByParity)
{
string groupName = group.Key ? “Even” : “Odd”;
Console.WriteLine($”{groupName}: {string.Join(“, “, group)}”);
}
Console.WriteLine($”\n Addition of Integers – {addition}”);
Console.WriteLine($”\n First Even Integer – {firstEvenIntegers}”);
Console.WriteLine($”First Even Or Default – {firstEvenOrDefault}”);
Console.WriteLine(“\n Distinct Integers -“);
Console.WriteLine(string.Join(“, “, distinctIntegers));
Console.WriteLine($”\n Any Even Numbers – {anyEven}”);
Console.WriteLine($”All Numbers Are Even – {allEven}”);
}
}
LINQ to Objects SQL query example and methods.
Here’s a more detailed example that shows you how to group multiple LINQ methods into a single program and display the output.
using System;
using System.Linq;
using System.Collections.Generic;
public class program
{
public static void Main()
{
var employees = new List<Employee>
{
new Employee { Emp_Name = “Bhavishi Deora”, Age = 24, Id = 101 },
new Employee { Emp_Name = “Siddhi Deora”, Age = 22, Id = 102 },
new Employee { Emp_Name = “Harry”, Age = 27, Id = 103 },
new Employee { Emp_Name = “Amit”, Age = 23, Id = 104 },
new Employee { Emp_Name = “Vivek”, Age = 37, Id = 105 }
};
//here we use sql query syntax
var query = from emp in employees
where emp.Age >= 21
select emp;
//here we use sql method syntax
var method = employees.Where(emp => emp.Age >= 30);
Console.WriteLine(“\n Display Employees info aged 21 or above with Query Syntax.”);
foreach (var emp in query)
{
Console.WriteLine($”ID – {emp.Id}, Employee Name – {emp.Emp_Name}, Age – {emp.Age}”);
}
Console.WriteLine(“\n Display Employees age 21 or above with Method Syntax.”);
foreach (var emp in method)
{
Console.WriteLine($”ID – {emp.Id}, Employee Name – {emp.Emp_Name}, Age – {emp.Age}”);
}
// here we use Group employees by Age
var groupedByAge = employees.GroupBy(emp => emp.Age);
Console.WriteLine(“\n Grouped by Age:”);
foreach (var group in groupedByAge)
{
Console.WriteLine($”\n Age Group = {group.Key}”);
foreach (var emp in group)
{
Console.WriteLine($”ID – {emp.Id}, Name – {emp.Emp_Name}”);
}
}
}
public class employee
{
public string Emp_Name { get; set; }
public int Age { get; set; }
public int Id { get; set; }
}
}
Objects SQL query example and methods explanation.
- In this example, we have a List<Employee>, and we apply LINQ methods to the SQL clauses, such as Where, GroupBy, and Select. The database query and method syntax are displayed side-by-side to preview the differences in style.
LINQ to SQL and Entity Framework in C#.
The LINQ connection method in a C# program can also be used with databases via LINQ to SQL or Entity Framework. This allows you to create database queries in C#, allowing you to interact with relational database query information in a very real-world, SQL-like style.
Example of using the LINQ connection method with Entity Framework in C#.
using (var context = new MyDbContext())
{
var employees = context.Employees
.Where(e => e.Department == “MARKETING”)
.OrderBy(e => emp.Name)
.ToList();
}
Using the LINQ connection method with Entity Framework in the example.
- In this example, context.Employees represents a table in the database, and the LINQ connection queries the data, just like SQL, but directly in C#.
Detailed summary of the LINQ database connection method.
- LINQ in C# allows user programs to perform database query operations in short, declarative steps using the Query Syntax or Method Syntax.
- LINQ methods simplify the data manipulation process by querying SQL database methods like Where, Select, GroupBy, and OrderBy.
- LINQ helps C# users access and retrieve queries from a variety of data sources, such as in-memory collections, databases, XML, and more.
- Deferred execution is a key feature here, meaning that database queries are executed only when needed. LINQ in C# is a vital database access query tool with many uses. It is commonly used with collections, databases like Entity Framework or LINQ to SQL, and even XML databases.
