用 LINQ 讓 C# 資料查詢變得更簡單：便利的資料查詢與操作實踐指南

今天我們來聊聊 C# 中的一個非常強大而優雅的功能——LINQ（Language Integrated Query），它可以利用類似SQL的語法對物件進行處理，包括集合、數組、XML、資料庫等，無論你是 C# 的新手還是已經有點經驗的開發者，LINQ 使操作資料變得簡單且直觀，今天我們來看看LINQ強大的威力吧。

集合方法

IEqualityComparer比較器

Distinct、Union、Intersect、Except這四個方法使用預設比較器，可以對字串、數字型態等集合來計算。我們來試看看類別集合是不是也能判斷？首先，我們定義Product的類別，裡面有 Name 和 Price 的屬性

C#
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

接者分別產生兩個類別集合，讓products1和products2分別有Name為Product1跟Price為10的元素，放在Intersect的方法，這個方法會回傳兩個集合的交集元素。

C#
List<Product> products1 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 20 },
    new Product { Name = "Product3", Price = 30 }
};

List<Product> products2 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product3", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};

var result = products1.Intersect(products2).Count();
////0

雖然這兩個集合分別有相同的屬性，但使用Intersect方法回傳結果是空的，原因是因為這兩個產生出來的實例會不一樣，如果想要根據屬性比較，就要實作IEqualityComparer。

IEqualityComparer要實作兩個方法，第一個Equals用來定義元素的屬性是否相等，GetHashCode 是產生元素的雜湊碼(HashCode)，也是判斷內容是否相等的判斷之一。

C#
class ProductComparer : IEqualityComparer<Product>
{
    ///比較 Product 類別的名稱和價格是否相同
    public bool Equals(Product x, Product y)
    {
        return x.Name == y.Name && x.Price == y.Price;
    }

    ///結合名稱和價格的值，唯一的雜湊碼
    public int GetHashCode(Product obj)
    {
        return $"{obj.Name}{obj.Price}".GetHashCode();
    }
}

後面的範例我們就會使用這個比較器，來看使用不同的方法，會回傳什麼資料。

Distinct 移除集合重複資料

Distinct可以集合中重複的元素。

此方法有兩個多載，第一個是使用預設的方法，第二個方法可以實作IEqualityComparer<T>方法比較重複元素來過濾。

C#
IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source);
IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
參數說明
source來源集合
comparer(第二個方法)比較元素相等的比較器
參數說明

範例1：Distinct() 返回集合中的獨立元素。

C#
 List<int> products = new List<int> { 1, 2, 2, 5, 5, 6, 7 };
 var result = products.Distinct();
 ////1,2,5,6,7

範例2：實作IEqualityComparer比較器，返回不重複的元素。

C#
List<Product> products = new List<Product>
{
    new Product { Name = "Product1", Price = 20.75m },
    new Product { Name = "Product1", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};

///------不使用比較器---------
var result = products.Distinct();
///Name:Product1 Price:20.75
///Name:Product1 Price:20.75
///Name:Product3 Price:5.25

///-----使用自訂義比較器------
var result = products.Distinct(new ProductComparer());
///Name:Product1 Price:20.75
///Name:Product3 Price:5.25

Union 合併兩個集合

Union用來合併兩個集合，也會去除重複的元素。

此方法有兩個多載，第一個是使用預設的方法；第二個方法可以實作IEqualityComparer<T>來過濾重複的元素。

C#
IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> source);
IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
參數說明
source來源集合
comparer(第二個方法)比較元素相等的比較器
參數說明

範例1：Union() 合併兩個集合

C#
List<int> firstCollection = new List<int> { 1, 2, 3, 4 };
List<int> secondCollection = new List<int> { 3, 4, 5, 6 };

var combinedCollection = firstCollection.Union(secondCollection);
///1、2、3、4、5、6

範例2：實作IEqualityComparer比較器，合併兩個集合

C#
List<Product> products1 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 20 },
    new Product { Name = "Product3", Price = 30 }
};

List<Product> products2 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product3", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};

///------不使用比較器---------
var result = products1.Union(products2).ToList();
///Name:Product1 Price:10
///Name:Product2 Price:20
///Name:Product3 Price:30
///Name:Product1 Price:10
///Name:Product3 Price:20.75
///Name:Product3 Price:5.25

///-----使用自訂義比較器------
var result = products1.Union(products2, new ProductComparer()).ToList();
///Name:Product1 Price:10
///Name:Product2 Price:20
///Name:Product3 Price:30
///Name:Product3 Price:20.75
///Name:Product3 Price:5.25

Intersect 取得兩個集合的交集

Intersect方法用來取得兩個集合的交集。

此方法有兩個多載，第一個是使用預設的方法；第二的方法可以實作IEqualityComparer<T>來判斷重複的元素。

C#
IEnumerable<TSource> Intersect <TSource>(this IEnumerable<TSource> source);
IEnumerable<TSource> Intersect <TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
參數說明
source來源集合
comparer(第二個方法)比較元素相等的比較器
參數說明

範例1：Intersect() 計算兩個集合交集的元素

C#
 List<int> firstCollection = new List<int> { 1, 2, 3, 4 };
 List<int> secondCollection = new List<int> { 3, 4, 5, 6 };

 var combinedCollection = firstCollection.Intersect(secondCollection);
 ///3、4

範例2：實作IEqualityComparer比較器，回傳兩集合交集的元素

C#
List<Product> products1 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 20 },
    new Product { Name = "Product3", Price = 30 }
};

List<Product> products2 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product3", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};
///------不使用比較器---------
var result = products1.Intersect(products2).ToList();
///

///-----使用自訂義比較器------
var result = products1.Union(products2, new ProductComparer()).ToList();
///Name:Product1 Price:10

Except 從一個集合排除另一個集合的元素

Except方法用來從一個集合中排除另一個集合中的元素。如果元素在第一個跟第二個集合同時存在，這個元素也會排除。

此方法有兩個多載，第一個是使用預設的方法；第二的方法可以實作“>IEqualityComparer<T>方法來判斷重複的元素。

範例1：使用 Except() 方法從 firstCollection 中排除 secondCollection 的元素

C#
 List<int> firstCollection = new List<int> { 1, 2, 3, 4, 5 };
 List<int> secondCollection = new List<int> { 4, 5, 6, 7 };

 var difference = firstCollection.Except(secondCollection);
 ///

範例2：實作IEqualityComparer比較器，從 firstCollection 中排除 secondCollection 的元素

C#
List<Product> products1 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 20 },
    new Product { Name = "Product3", Price = 30 }
};

List<Product> products2 = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product3", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};

///------不使用比較器---------
var result = products1.Except(products2).ToList();
///Name:Product1 Price:10
///Name:Product2 Price:20
///Name:Product3 Price:30

///-----使用自訂義比較器------
var result = products1.Except(products2, new ProductComparer()).ToList();
///Name:Product2 Price:20
///Name:Product3 Price:30

聚合方法

Count 計算數量

Count用來計算集合的總數量。

第一個方法是回傳集合總數量；第二個方法是回傳指定條件的數量。

C#
Count<TSource>(IEnumerable<TSource> source)
Count<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)
參數說明
source來源集合
predicate(第二個方法)篩選的條件
參數說明

範例1：Count()計算集合的總數量

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int totalCount = numbers.Count();
///5

範例2：Count()計算集合中偶數元素的總數量

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int totalCount = numbers.Count(i=> i % 2 == 0);
///2

Sum 計算加總

Sum計算集合的加總，根據集合中的型態回傳不同的結果，此方法可以指定篩選函式來進行求和。如果計算集合為空，回傳值為0。

C#
int Sum(IEnumerable<int> source);
long Sum(IEnumerable<long> source);
double Sum(IEnumerable<double> source);
decimal Sum(IEnumerable<decimal> source);
float Sum(IEnumerable<float> source);

int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
參數說明
source來源集合
selector篩選的條件
參數說明

範例1：針對不同的形態集合，進行加總

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int totalSum = numbers.Sum();// 結果為 15

List<long> numbers = new List<long> { 10000000000, 20000000000, 30000000000 };
long sum = numbers.Sum(); // 結果為 60000000000

List<double> numbers = new List<double> { 1.1, 2.2, 3.3 };
double totalSum = numbers.Sum(); // 結果為 6.6

List<decimal> numbers = new List<decimal> { 1.1m, 2.2m, 3.3m };
decimal totalSum = numbers.Sum(); // 結果為 6.6

List<float> numbers = new List<float> { 1.1f, 2.2f, 3.3f };
float totalSum = numbers.Sum(); // 結果為 6.6

範例2：針對物件的集合屬性，進行加總

C#
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
C#
List<Product> products = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 30 },
    new Product { Name = "Product3", Price = 20 }
};
var sum = products.Sum(p => p.Price);
///60

Average 計算平均值

Average計算集合的平均，根據集合中的型態回傳不同的結果，不同的形態可以指定轉換函式來進行求和。如果集合為空，則會拋出InvalidOperationException。

C#
double Average(IEnumerable<int> source);
double Average(IEnumerable<long> source);
double Average(IEnumerable<double> source);
decimal Average(IEnumerable<decimal> source);
float Average(IEnumerable<float> source);

double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
float Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
參數說明
source來源集合
selector篩選的條件
參數說明

範例1：針對一個的數字集合，進行平均值計算

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
double totalSum = numbers.Average();// 結果為 3

Min、Max 尋找集合最小最大值元素

Min、Max方法用於尋找集合中的最小值及最大值，可以處理不同類型的型態集合。如果集合為空，則會拋出InvalidOperationException。

C#
int Min(IEnumerable<int> source);
long Min(IEnumerable<long> source);
double Min(IEnumerable<double> source);
decimal Min(IEnumerable<decimal> source);
float Min(IEnumerable<float> source);

TResult Min<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
C#
int Max(IEnumerable<int> source);
long Max(IEnumerable<long> source);
double Max(IEnumerable<double> source);
decimal Max(IEnumerable<decimal> source);
float Max(IEnumerable<float> source);

TResult Max<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
參數說明
source來源集合
selector篩選的條件
參數說明

範例1：尋找一個數字集合的最小及最大值

C#
List<int> numbers = new List<int> { 3, 1, 4, 1, 5, 9, 2, 6, 5 };
int minValue = numbers.Min(); ///1
int maxValue = numbers.Max(); ///9

範例2：尋找最低及最高產品價格

C#
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
C#
List<Product> products = new List<Product>
{
    new Product { Name = "Product1", Price = 10.5m },
    new Product { Name = "Product2", Price = 20.75m },
    new Product { Name = "Product3", Price = 5.25m }
};

decimal minPrice = products.Min(p => p.Price); ///5.25
decimal maxPrice = products.Max(p => p.Price); ///20.75

查詢方法

Where 篩選指定條件的元素

Where可以根據指定的條件來篩選集合中的元素。第一個方法是基本條件篩選，第二個方法可以多傳入索引值來篩選資料。

C#
Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
參數說明
source要來源序列
selector(方法2)篩選集合的條件
參數說明

範例1：產生1到20的集合，篩選5的倍數元素。

C#
var numberList = Enumerable.Range(1, 20).ToList();
var result = numberList.Where(i => i % 5 == 0).ToList();
///5、10、15、20

範例2：對物件集合的某個屬性進行加總。

C#
string[] words = { "apple", "banana", "orange", "grape" };
var result = words.Where(word => word.StartsWith("a"));
///apple

範例3：對物件集合進行搜尋，尋找Name為Bob的元素。

C#
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
C#
List<Product> products = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 20 },
    new Product { Name = "Product3", Price = 30 }
};
var result = products.Where(i => i.Name == "Product1");
///Name: Product1, Price : 10

範例4：產生1到20的集合，查詢元素為5倍數且值索引為偶數。

C#
var numberList = Enumerable.Range(1, 20).ToList();
var result = numberList.Where((i, index)=>  i % 5 == 0 && index % 2 == 0).ToList();///5、15

Select 對元素進行轉換，並返回轉換後的結果序列

Select可以將集合中的元素映射到另一個型態，第一個方法只能傳入一個函數，用來定義如何轉換集合中的每個元素，第二個方法可以額外定義索引。

C#
Select<TSource, TResult>(IEnumerable<TSource> source,Func<TSource, int, TResult> selector)
Select<TSource, TResult>(IEnumerable<TSource> source,Func<TSource, TResult> selector)
參數說明
source要印射來源序列
selector方法1：透過加入項目的索引，映射集合的項目
方法2：映射集合的項目。
參數說明

範例1：映射一個數字集合，每個元素的平方。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };        
var squares = numbers.Select(x => x * x);
///1、4、9、16、25

範例2：映射一個集合的索引及元素。

C#
List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
var indexedFruits = fruits.Select((fruit, index) => $"Index {index}: {fruit}");
///Index 0: Apple
///Index 1: Banana
///Index 2: Cherry

OrderBy/OrderByDescending 升序/降序排列

OrderBy/OrderByDescending用於根據指定的屬性對序列中的元素進行升序或降序排列。第一個方法使用預設的比較器進行排序，第二個方法可以傳入自訂的比較器。

C#
OrderBy<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
OrderBy<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
參數說明
source要排序的來源序列
keySelector擷取索引鍵的函式
comparer比較兩個物件的方法
參數說明

範例1：對一個整數集合進行升序排序。

C#
List<int> numbers = new List<int> { 5, 3, 8, 1, 2 };
var sortedNumbers = numbers.OrderBy(x => x);
///1,2,3,5,8

範例2：有一個字串集合，按字串的進行排序。

C#
 List<string> words = new List<string> { "apple", "banana", "cherry", "date" };
var sortedWords = words.OrderBy(word => word.Length);
///date, apple, banana, cherry

範例3：對集合物件的某個屬性進行排序。

C#
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
C#
List<Product> products = new List<Product>
{
    new Product { Name = "Product1", Price = 10 },
    new Product { Name = "Product2", Price = 30 },
    new Product { Name = "Product3", Price = 20 }
};
var sortedPrice = products.OrderBy(person => person.Price);
///Name:Product1 Price:10
///Name:Product3 Price:20
///Name:Product2 Price:30

範例4：傳入StringComparer.OrdinalIgnoreCase不區分大小寫的比較器進行排序

C#
List<string> words = new List<string> { "apple", "Banana", "cherry", "Date" };        
var sortedWords = words.OrderBy(word => word, StringComparer.OrdinalIgnoreCase);///apple, Banana, cherry, Date

將OrderBy換成OrderByDescending即可回傳降序結果。

ThenBy/ThenByDescending對排序後的結果再進行後續排序作業

ThenBy/ThenByDescending方法可對已排序的集合再進行排序。與 OrderBy 和 OrderByDescending 一起使用。

範例1：我們有一個 Product 類別集合，先按Price升序排序，再按Name升序排序。

C#
 List<Product> products = new List<Product>
 {
     new Product { Name = "ProductA", Price = 20 },
     new Product { Name = "ProductB", Price = 15 },
     new Product { Name = "ProductA", Price = 10 },
     new Product { Name = "ProductC", Price = 20 },
     new Product { Name = "ProductB", Price = 30 }
 };
 var result = products
 .OrderBy(p => p.Price)  ///先根據價格    
 .ThenBy(p => p.Name)   ///再根據名稱
 .ToList();
///Name:ProductA Price:10
///Name:ProductB Price:15
///Name:ProductA Price:20
///Name:ProductC Price:20
///Name:ProductB Price:30

將ThenBy換成ThenByDescending即可回傳降序結果。

分區方法

Skip跳過集合中的前 n 個元素

Skip方法用來跳過元素前n個元素，並返回剩餘的元素。

Skip提供兩個方法，第一是跳過集合前n個元素，第二的方法是提供一個判斷的方法，是否要跳過元素。

C#
IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count);  
IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
參數說明
source來源序列
count(方法1)要跳過的元素数量
predicate(方法2)判斷元素是否要跳過的方法
參數說明

範例1：使用Skip()跳過前n個元素。

C#
List<int> nums = new List<int> { 1, 2, 3, 4, 5 };
var skippedNums = nums.Skip(2).ToList();
///3、4、5

範例2：使用SkipWhile()，跳過小於4的元素。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var skippedNumbers = numbers.SkipWhile(n => n < 4).ToList();
///4、5、6

Take返回集合中的前n個元素

Task與Skip相對應，取前n個元素。

Take提供兩個方法，第一是取集合前n個元素，第二的方法是提供一個判斷的方法，判斷每個元素是否應該被納入結果中。

C#
IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count);  
IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
參數說明
source來源序列
count(方法1)要跳過的元素数量
predicate(方法2)判斷元素是否要跳過的方法
參數說明

範例1：使用Take()取前n個元素。

C#
List<int> nums = new List<int> { 1, 2, 3, 4, 5 };
var skippedNums = nums.Take(2).ToList();
///1、2

範例2：使用SkipWhile()，取小於4的元素。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };  
var takenNumbers = numbers.TakeWhile(n => n < 4).ToList();
///1、2、3

選擇方法

First/Last返回集合的第一/最後一個元素

First與Last分別用來取得集合中第一個與最後一個元素，如果集合是空的，會拋Exception

C#
TSource First<TSource>(this IEnumerable<TSource> source);  
TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
C#
TSource Last<TSource>(this IEnumerable<TSource> source);  
TSource Last<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
參數說明
source來源序列
predicate(方法2)一個函數，用於判斷元素是否符合條件
參數說明

First與Last提供兩個方法，第一個是取集合的第一個元素，第二的方法是提供一個判斷的方法，取得符合方法的第一個元素。

方法1：First/Last取得第一/最後個元素。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int firstNumber = numbers.First();
///1

int firstNumber = numbers.Last();
///5

方法2：First/Last取得第一個偶數的元素。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int firstNumber = numbers.First(i => i % 2 == 0);
///2

int firstNumber = numbers.Last(i => i % 2 == 0);
///4

FirstOrDefault/LastOrDefault返回集合中的第一/最後一個元素，如果集合為空則返回預設值

FirstOrDefault返回集合中第一個元素，與First用法類似，差在如果集合為空，則返回該型態的默認值，而First會Exception，使得 FirstOrDefault在使用上不會出現Exception的狀況。

FirstOrDefault/LastOrDefault分別提供兩個方法，第一個是取集合的第一個與最後一個元素，第二的方法是提供一個判斷的方法，取得符合方法的第一個跟最後一個元素。

C#
TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source);  
TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
參數說明
source來源序列
predicate(方法2)一個函數，用於判斷元素是否符合條件
參數說明

方法1：FirstOrDefault/LastOrDefault對空集合取得第一個與最後一個元素，會回傳int型態的預測值為0。

C#
List<int> numbers = new List<int> { };
int firstNumber = numbers.FirstOrDefault();
///0

int lastNumber = numbers.LastOrDefault();
///0

方法2：FirstOrDefault/LastOrDefault取得第一個與最後一個偶數的元素，但集合沒有偶數的元素，所以返回0。

C#
List<int> numbers = new List<int> { 1, 3, 5, 7 };
int firstNumber = numbers.FirstOrDefault(i => i % 2 == 0);
///0

int lastNumber = numbers.LastOrDefault(i => i % 2 == 0);
///0

Single返回集合中唯一元素

Single用來從取得集合中唯一的元素。與 First 和 FirstOrDefault 不同，Single 會檢查集合中若集合為空或有多於一個元素，則會拋出異常。

C#
TSource Single<TSource>(this IEnumerable<TSource> source);  
TSource Single<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
參數說明
source來源序列
predicate(方法2)一個函數，用於判斷元素是否符合條件
參數說明

方法1：Single取唯一的元素

C#
List<int> numbers = new List<int> { 5 };  
int singleNumber = numbers.Single();  
///5

方法2：Single取唯一的偶數元素

C#
List<int> numbers = new List<int> { 1, 3, 5, 4, 7 };
int singleEvenNumber = numbers.Single(n => n % 2 == 0);
///4

SingleOrDefault返回集合中唯一的一個元素，集合為空返回型態預測值，多個元素拋出異常

SingleOrDefault這個方法與 Single 類似，用於從集合中獲取唯一的元素。但如果集合為空，SingleOrDefault 會返回該類型的默認值，而不會拋出異常，但如果有多個元素，則會拋Exception。

C#
TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source);  
TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);

方法1：SingleOrDefault取唯一的元素，因為集合為空，返回預設值 0

C#
List<int> numbers = new List<int>();
int singleNumber = numbers.SingleOrDefault();
///0

方法2：SingleOrDefault取符合偶數唯一的元素，都沒有符合條件，因此返回預設值 0

C#
List<int> numbers = new List<int> { 1, 3, 7, 9, 11 };
int singleEvenNumber = numbers.SingleOrDefault(n => n % 2 == 0);
標籤
分享這篇文章

其他文章

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *