using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
namespace app
{
/*
Type Converter: Enumerable.AsEnumerable
Queryable.AsQueryable
Enumerable / Queryable.Cast
Enumerable / Queryable.OfType
Enumerable.ToArray
Enumerable.ToDictionary
Enumerable.ToList
Enumerable.ToLookup - to one-2-many dictionary
Elements: ElementAt,
ElementAtOrDefault,
First,
FirstOrDefault,
Last,
LastOrDefault,
Single,
SingleOrDefault
Equal: Enumerable / Queryable.SequenceEqual() - 通過以成對方式比較元素確定兩個序列是否相等。
Generator: - 生成是指創建新的值序列
Enumerable / Queryable.DefaultEmpty - 用默認值單一實例集合替換空集合
Enumerable.Empty - 返回一個空集合
Enumerable.Range - 生成包含數字序列的集合
Enumerable.Repeat - 生成包含一個重復值的集合
Group: - 分組是指將數據分到不同的組，使每組中的元素擁有公共的屬性。
Enumerable / Queryable.Groupby - group...by.. | group...by...into...
Enumerable.ToLookup - to one-2-many dictionary - 將元素插入基於鍵選擇器函數的
Join: Enumerable / Queryable.Join
Enumerable / Queryable.GroupJoin
PartitionData: - 將輸入序列划分為兩個部分的操作，無需重新排列元素，然后返回其中一個部分
Enumerable / Queryable.Skip
Enumerable / Queryable.SkipWhile -基於謂詞函數跳過元素，直到元素不符合條件
Enumerable / Queryable.Take
Enumerable / Queryable.TakeWhile - 基於謂詞函數獲取元素，直到元素不符合條件
Projection:
- 投影是指將對象轉換為一種新形式的操作，該形式通常只包含那些將隨后使用的屬性。
- 通過使用投影，您可以構造從每個對象生成的新類型。
- 可以投影屬性，並對該屬性執行數學函數。 還可以在不更改原始對象的情況下投影該對象。
Enumerable / Queryable.Select
Enumerable / Queryable.SelectMany
Quantifier:
- 返回一個 Boolean 值，該值指示序列中是否有一些元素滿足條件或是否所有元素都滿足條件
Enumerable / Queryable.All
Enumerable / Queryable.Any
Enumerable / Queryable.Contains
Filtering:
- 結果集限制為僅包含滿足指定條件的元素的操作。 它也稱為選定內容
Enumerable / Queryable.OfType
Enumerable / Queryable.Where
u
Set Operation:
- 集運算是指根據相同或不同集合（或集）中是否存在等效元素來生成結果集的查詢運算
Enumerable / Queryable.Distinct - 刪除集合中的重復值。
Enumerable / Queryable.Except - 差集指位於一個集合但不位於另一個集合的元素。
Enumerable / Queryable.Intersect - 交集指同時出現在兩個集合中的元素
Enumerable / Queryable.Union - 返回並集，並集指位於兩個集合中任一集合的唯一的元素
Others: Append,
Reverse,
Then
Zip - 指定函數應用於兩個序列的對應元素，以生成結果序列。
*
*/
public class LinqDemo
{
List<int> list = new List<int>();
public void TryLinq()
{
List<int> scores = new List<int>() { 80, 70, 90, 100 };
IEnumerable<string> highScore = from score in scores
where score > 80
orderby score descending
select $"The score is {score}";
foreach (var item in highScore)
{
System.Console.WriteLine(item);
}
//=============================================================================================
Country[] countries = { new Country(), new Country() };
// to produce a sequence of groups organized by a key.
var queryCountryGroup = from country in countries group country by country.Name;
// select to generate a new type
var queryNameAndPop = from country in countries
select new { Name = country.Name, Pop = country.Population };
// into - create a temporary identifier that stores a query.
var percentQuery = from country in countries
let percentile = (int)country.Population / 10_000_000
group country by percentile into countryGroup
where countryGroup.Key >= 20
orderby countryGroup.Key
select countryGroup;
// oderby - ascending or descending.
var querySortedCountries = from country in countries
orderby country.Name, country.Population descending
select country;
// join - associate and/or combine elements from one data source with from others
// let - to store the result of an expression. such as a method call.
string[] names = { "Omel DDD", "Claire ss", "Sven d", "Cesar s" };
var queryNames = from name in names
let firstName = name.Split(' ')[0]
select firstName;
// subquery
Student[] students = { new Student(), new Student() };
//- to to checked
var queryGroupMax = from student in students
group student by student.GradeLevel into studentGroup
select new
{
Level = studentGroup.Key,
HighestScore = (from student2 in studentGroup select student2.Scores.Average()).Max()
};
}
// Aggregate -
public void AggregateDemo()
{
}
// All [bool] - Determines whether all elements of a sequence satisfy a condition
public bool All_Demo(string[] strs)
{
return strs.All((n) => n.StartsWith('a'));
}
// Any [bool] - Determines whether a sequence contains any elements.
public bool Any_Demo(string[] strs)
{
return strs.Any((n) => n.EndsWith('/'));
}
}
public class Country
{
public string City { get; set; }
public string Name { get; set; }
public int Population { get; set; }
}
}
static void Main(string[] args)
{
Student[] studentsInClassOne =
{
new Student(){Name = "AinOne", Age = 18, GradeLevel = 1},
new Student(){Name = "BinOne", Age = 20, GradeLevel = 3},
new Student(){Name = "CinOne", Age = 16, GradeLevel = 1},
new Student(){Name = "DinOne", Age = 17, GradeLevel = 4},
new Student(){Name = "EinOne", Age = 18, GradeLevel = 1}
};
Student[] studentsInClassTwo =
{
new Student(){Name = "AinTwo", Age = 18, GradeLevel = 1},
new Student(){Name = "BinTwo", Age = 20, GradeLevel = 5},
new Student(){Name = "CinTwo", Age = 18, GradeLevel = 1},
new Student(){Name = "DinTwo", Age = 16, GradeLevel = 9},
new Student(){Name = "EinTwo", Age = 17, GradeLevel = 4}
};
// all statement is to check the LINQ functions both in Linq expression and Method
//Elements: ElementAt(int index), First()
// Single() -
var stuOnElementsOperation = studentsInClassOne.ElementAt(1);
var stuFirst = studentsInClassOne.First();
Student singStudent = null;
if (studentsInClassTwo.Length != 1)
{
singStudent = studentsInClassTwo.First();
}
else
{
singStudent = studentsInClassTwo.Single();
}
/*
Console.WriteLine(stuOnElementsOperation.Name);
Console.WriteLine(stuFirst.Name);
Console.WriteLine(singStudent.Name);*/
// Generator - create a new sequence base on that.=======================
var range = Enumerable.Range(1, 150);
var repeat = Enumerable.Repeat(21, 15);
// Partition Data - Skip, SkipWhile, Take, TakeWhile=====================
// SkipWhile()
// TakeWhile: loop each element, stop while false, return element have been looped that matched.
var rangSkip = range.Skip(15);
var rangeSkipWhile = range.SkipWhile(n => (n % 3 != 0));
var rangeTake = range.Skip(15).Take(5);
var rangeTakeWhile = range.Skip(9).TakeWhile(n => n > 10);
string[] strList =
{
"One", "Two", "Three", "Five", "Six"
};
var resultList = strList.SkipWhile(s => s.Length < 4); // "Three", "Five", "Six"
int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var numbersSkipWhile = numbers.SkipWhile(n => n % 3 != 0); // 3, 9, 8, 6, 7, 2, 0
//==================================================================================
// Quantifier - All, Any, Contains
bool isAll = numbers.All(n => n % 3 == 0);
bool isAny = numbers.Any(n => n % 3 == 0);
bool isContains = numbers.Contains(8);
bool isObject = studentsInClassOne.Contains(new Student() { Name = "EinOne", Age = 18, GradeLevel = 1 });
Console.WriteLine("IsAll:{0}, IsAny:{1}, isObject:{2}", isAll, isAny, isObject);
//==================================================================================
// Filtering - OfType, Where
var stuFilter = studentsInClassOne.Union(studentsInClassTwo).Where(n => n.GradeLevel == 12); // null, Not Execption throwed.
foreach (var VARIABLE in stuFilter)
{
Console.WriteLine("Name:{0},Age:{1},GradeLevel:{2}", VARIABLE.Name, VARIABLE.Age, VARIABLE.GradeLevel);
}
//==================================================================================
// Append, Reverse, Then, Zip
var newnumbers = numbers.Append(100);
int[] first = { 1, 2, 3, 4, 5 };
int[] second = { 6, 7, 8, 9, 10 };
var zipNumbers = first.Zip(second, (n, m) => n * m); // 6,14,36,50 Use Zip To preform.
foreach (var number in zipNumbers)
{
Console.WriteLine(number);
}
}
