public class Linq
{
MXSICEDataContext Db = new MXSICEDataContext();
// LINQ to SQL
// Count/Sum/Min/Max/Avg
// Count
public void Count()
{
// 說明：返回集合中的元素個數，返回 INT 類型；不延遲。生成 SQL 語句爲： SELECT COUNT(*) FROM
//簡單形式 性能差
var count = Db.MXSMemeber.Count();
//帶條件形式
var count1 = Db.MXSMemeber.Count(a => bool.Parse(a.UID));
// LongCount
//說明 ：返回集合中的元素個數，返回 LONG 類型；不延遲。對於元素個數較多的集合可 視
//情況可以選用 LongCount 來統計元素個數，它返回 long 類型，比較精確。生成 SQL 語句爲：
//SELECT COUNT_BIG(*) FROM
var longcount = Db.MXSMemeber.LongCount();
}
//SUM
public void SUM()
{
///同樣來個簡單形式
///
var sum = Db.MXSMemeber.Select(a => a.Sex).Sum();
///映射形式
///
var sum1 = Db.MXSMemeber.Sum(a => decimal.Parse(a.UID));
}
///Min
public void Min()
{
// 說明：返回集合中元素的最小值；不延遲。 生成 SQL 語句爲： SELECT MIN(„) FROM
//簡單形式
var min = Db.MXSMemeber.Select(a => a.UID).Min();
//映射形式
var min1 = Db.MXSMemeber.Min(a => a.UID);
}
///Max
public void Max()
{
// 說明：返回集合中元素的最大值；不延遲。生成 SQL 語句爲： SELECT MAX(„) FROM
//簡單形式
var max = Db.MXSMemeber.Select(a => a.UID).Max();
//映射形式：
var max1 = Db.MXSMemeber.Max(a => a.UID);
}
//Average
public void Average()
{
// 說明：返回集合中的數值類型元素的平均值。集合應爲數字類型集合，其返回 值類型爲
//double；不延遲。生成 SQL 語句爲： SELECT AVG(„) FROM
//簡單形式
var Average = Db.MXSMemeber.Select(a => decimal.Parse(a.UID)).Average();
//映射形式
var Average1 = Db.MXSMemeber.Average(a => decimal.Parse( a.UID));
}
//Join
//適用場景：在我們表關係中有一對一關係，一對多關係， 多對多關係等。對各個表之間的
//關係，就用這些實現對多個表的操作。
//說明：在Join 操作中，分別爲Join(Join 查詢), SelectMany(Select 一對多選擇) 和GroupJoin(分
//組Join 查詢)。
//該擴展方法對兩個序列中鍵匹配的元素進 行inner join 操作
//SelectMany
//說明：我們在寫查詢語句時，如果 被翻譯成SelectMany 需要滿足2 個條件。1：查詢語句
//中沒有join 和 into，2：必 須出現 EntitySet。在我們表關係中有一對一關係，一對多關係，
//多對多關係等 ，下面分別介紹一下。
//1.一對多關係(1 to Many)：
var q =
from c in Db.Customers
from o in c.Orders
where c.City == "London"
select o;
//語句描述：Customers 與Orders 是一對多關係。即Orders 在Customers 類中以 EntitySet 形
//式出現。所以第二個from 是從c.Orders 而不是Db.Orders 裏進行篩選 。這個例子在From 子
//句中使用外鍵導航選擇倫敦客戶的所有訂單。
var q =
from p in Db.Products
where p.Supplier.Country == "USA" && p.UnitsInStock == 0
select p;
//語句描述：這一句使用了 p.Supplier.Country 條件，間接關聯了Supplier 表。這個例子在Where
//子句中使 用外鍵導航篩選其供應商在美國且缺貨的產品。生成SQL 語句爲：
SELECT [t0].[ProductID], [t0].[ProductName], [t0]. [SupplierID],
[t0].[CategoryID],[t0].[QuantityPerUnit],[t0]. [UnitPrice],
[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0]. [ReorderLevel],
[t0].[Discontinued] FROM [dbo].[Products] AS [t0]
LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON
[t1]. [SupplierID] = [t0].[SupplierID]
WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1)
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]
//2.多對多關係(Many to Many)：
var q =
from e in Db.Employees
from et in e.EmployeeTerritories
where e.City == "Seattle"
select new
{
e.FirstName,
e.LastName,
et.Territory.TerritoryDescription
};
//說明：多對多關係一般會涉及三個表(如果有一個表是自關 聯的，那有可能只有 2 個表)。
//這一句語句涉及Employees, EmployeeTerritories, Territories 三個表。它們的關係是1：M：1。
//Employees 和Territories 沒有很明確的關係。
//語句描述：這個例子在 From 子句中使 用外鍵導航篩選在西雅圖的僱員，同時列出其所在
//地區。這條生成SQL 語句爲：
SELECT [t0].[FirstName], [t0].[LastName], [t2]. [TerritoryDescription]
FROM [dbo].[Employees] AS [t0] CROSS JOIN [dbo].[EmployeeTerritories]
AS [t1] INNER JOIN [dbo]. [Territories] AS [t2] ON
[t2].[TerritoryID] = [t1].[TerritoryID]
WHERE ([t0].[City] = @p0) AND ([t1].[EmployeeID] = [t0]. [EmployeeID])
-- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Seattle]
//3. 自聯接關係：
var q =
from e1 in Db.Employees
from e2 in e1.Employees
where e1.City == e2.City
select new {
FirstName1 = e1.FirstName, LastName1 = e1.LastName,
FirstName2 = e2.FirstName, LastName2 = e2.LastName,
e1.City
};
//語句描述：這個例子在select 子句中使用外鍵導航篩選成 對的僱員，每對中一個僱員隸屬
//於另一個僱員，且兩個僱員都來自相同城市。生 成SQL 語句爲：
SELECT [t0].[FirstName] AS [FirstName1], [t0].[LastName] AS
[LastName1],[t1].[FirstName] AS [FirstName2], [t1].[LastName] AS
[LastName2],[t0].[City] FROM [dbo].[Employees] AS [t0],
[dbo].[Employees] AS [t1] WHERE ([t0].[City] = [t1]. [City]) AND
([t1].[ReportsTo] = [t0].[EmployeeID])
GroupJoin
//像上面所說的，沒有join 和into，被翻譯成 SelectMany ，同時有join 和into 時，那麼就被
//翻譯爲GroupJoin 。在這裏into 的 概念是對其結果進行重新命名。
//1.雙向聯接(Two way join)：
//此 示例顯式聯接兩個表並從這兩個表投影出結果：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into orders
select new
{
c.ContactName,
OrderCount = orders.Count ()
};
//說明：在一對多關係中，左邊是1，它每條記錄 爲c （from c in Db.Customers ），右邊是Many，
//其每條記錄叫做o ( join o in Db.Orders ) ，每對應左邊的一個c，就會有一組o，那這一組o，
//就叫做orders， 也就是說，我們把一組o 命名爲orders，這就是into 用途。這也就是爲什
//麼在 select 語句中，orders 可以調用聚合函數Count。在T-SQL 中，使用其內嵌的T- SQL 返
//回值作爲字段值。如圖所示：
//生成SQL 語句爲：
SELECT [t0].[ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [OrderCount]
FROM [dbo].[Customers] AS [t0]
//2.三向聯接(There way join)：
//此示例顯式聯接三個表並分別從每個表投影出結果：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into ords
join e in Db.Employees on c.City
equals e.City into emps
select new
{
c.ContactName,
ords = ords.Count(),
emps = emps.Count()
};
//生成SQL 語句爲：
SELECT [t0]. [ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [ords], (
SELECT COUNT(*)
FROM [dbo].[Employees] AS [t2]
WHERE [t0].[City] = [t2].[City]
) AS [emps]
FROM [dbo].[Customers] AS [t0]
//3.左外部聯接(Left Outer Join)
//此示例說明如何通過使用 此示例說明如何通過使用 DefaultIfEmpty() 獲取左外部聯接。在
//僱員沒有訂單時，DefaultIfEmpty()方 法返回null：
var q =
from e in Db.Employees
join o in Db.Orders on e equals o.Employee into ords
from o in ords.DefaultIfEmpty()
select new
{
e.FirstName,
e.LastName,
Order = o
};
//說明：以Employees 左表，Orders 右表，Orders 表中爲空時， 用null 值填充。Join 的結果
//重命名 ords，使用 DefaultIfEmpty()函數對其再次查 詢。其最後的結果中有個 Order，因爲
//from o in ords.DefaultIfEmpty() 是對 ords 組再一次遍歷，所以，最後結果中的Order 並不是
//一個集合。但是，如果沒 有from o in ords.DefaultIfEmpty() 這句，最後的select 語句寫成select
//new { e.FirstName, e.LastName, Order = ords }的話，那麼Order 就是一個集合。
//4.投影的Let 賦值(Projected let assignment)：
//說明：let 語句 是重命名。let 位於第一個from 和select 語句之間。
//這個例子從聯接投影 出最終“Let”表達式：
var q =
from c in Db.Customers
join o in Db.Orders on c.CustomerID
equals o.CustomerID into ords
let z = c.City + c.Country
from o in ords
select new
{
c.ContactName,
o.OrderID,
z
};
//5.組合鍵(Composite Key)：
//這個例子顯示帶有組合 鍵的聯接：
var q =
from o in Db.Orders
from p in Db.Products
join d in Db.OrderDetails
on new
{
o.OrderID,
p.ProductID
} equals
new
{
d.OrderID,
d.ProductID
}
into details
from d in details
select new
{
o.OrderID,
p.ProductID,
d.UnitPrice
};
//說明：使用三個表，並且用匿名類來說明：使用三個表，並 且用匿名類來表示它們之間的
//關係。它們之間的關係不能用一個鍵描述清楚，所 以用匿名類，來表示組合鍵。還有一種
//是兩個表之間是用組合鍵表示關係的，不 需要使用匿名類。
//6.可爲null/不可爲null 的鍵關係 (Nullable/Nonnullable Key Relationship)：
//這個實例顯示如何構造一 側可爲 null 而另一側不可爲 null 的聯接
var q =
from o in Db.Orders
join e in Db.Employees
on o.EmployeeID equals
(int?)e.EmployeeID into emps
from e in emps
select new
{
o.OrderID,
e.FirstName
};
}
