LINQ 집계함수

• MAX 최대값을 반환하는
  
• MIN 최소값을 반환하는<
  
• SUM 모든 요소를 더한<
  
• COUNT 요소의 개수를 세아린<
  
• AVERAGE 요소들의 평균을 내는<
  
• CONTAINS 요소에 어떤 요소가 포함되었는지 판단하는<
  
• ALL 원하는 조건에 모든 요소가 해당하는지<
  
• ANY 원하는 조건이 하나의 요소라도 해당하는지<
  
• AGGREGATE 값을 누적하는<

---

시퀀스 요소 중 최대값을 반환하는 

MAX

 

기본

List<long> longs = new List<long> { 4294967296L, 466855135L, 81125L };

long max = longs.Max();

Console.WriteLine("The largest number is {0}.", max);

/*
 This code produces the following output:

 The largest number is 4294967296.
*/

 

대리자 정의

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public static void MaxEx4()
{
    Pet[] pets = { new Pet { Name="Barley", Age=8 },
                   new Pet { Name="Boots", Age=4 },
                   new Pet { Name="Whiskers", Age=1 } };

    int max = pets.Max(pet => pet.Age + pet.Name.Length);

    Console.WriteLine(
        "The maximum pet age plus name length is {0}.",
        max);
}

/*
 This code produces the following output:

 The maximum pet age plus name length is 14.
*/

 

 

 

---

시퀀스 요소 중 가장 작은 값을 반환하는

MIN

소스 시퀀스가 비어 있거나 null인 값만 포함된 경우 이 함수는 null를 반환합니다 .

 

기본

int?[] grades = { 78, 92, null, 99, 37, 81 };

int? min = grades.Min();

Console.WriteLine("The lowest grade is {0}.", min);

/*
 This code produces the following output:

 The lowest grade is 37.
*/

 

대리자 정의

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public static void MinEx4()
{
    Pet[] pets = { new Pet { Name="Barley", Age=8 },
                   new Pet { Name="Boots", Age=4 },
                   new Pet { Name="Whiskers", Age=1 } };

    int min = pets.Min(pet => pet.Age);

    Console.WriteLine("The youngest animal is age {0}.", min);
}

/*
 This code produces the following output:

 The youngest animal is age 1.
*/

 

 

 

 

---

시퀀스 요소를 모두 더하는

Sum

예외
ArgumentNullExceptionsource이(가) null인 경우
예외
ArgumentNullExceptionsource 또는 selector가 null인 경우

 

기본

List<float> numbers = new List<float> { 43.68F, 1.25F, 583.7F, 6.5F };

float sum = numbers.Sum();

Console.WriteLine("The sum of the numbers is {0}.", sum);

/*
 This code produces the following output:

 The sum of the numbers is 635.13.
*/

 

 

대리자 정의

class Package
{
    public string Company { get; set; }
    public double Weight { get; set; }
}

public static void SumEx1()
{
    List<Package> packages =
        new List<Package>
            { new Package { Company = "Coho Vineyard", Weight = 25.2 },
              new Package { Company = "Lucerne Publishing", Weight = 18.7 },
              new Package { Company = "Wingtip Toys", Weight = 6.0 },
              new Package { Company = "Adventure Works", Weight = 33.8 } };

    double totalWeight = packages.Sum(pkg => pkg.Weight);

    Console.WriteLine("The total weight of the packages is: {0}", totalWeight);
}

/*
 This code produces the following output:

 The total weight of the packages is: 83.7
*/

 

 

---

요소의 지정된 개수를 반환하는

Count

시퀀스의 개수를 세아려 반환

반환 Int32
입력 시퀀스의 요소 수입니다.
예외
ArgumentNullExceptionsource이(가) null인 경우
OverflowException의 source 요소 수가 Int32.MaxValue보다 큽습니다.

 

string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

try
{
    int numberOfFruits = fruits.Count();
    Console.WriteLine(
        "There are {0} fruits in the collection.",
        numberOfFruits);
}
catch (OverflowException)
{
    Console.WriteLine("The count is too large to store as an Int32.");
    Console.WriteLine("Try using the LongCount() method instead.");
}

// This code produces the following output:
//
// There are 6 fruits in the collection.

 

 

대리자를 통해 true 값을 세아려 반환

predicateFunc<TSource,Boolean>
각 요소를 조건에 대해 테스트하는 함수입니다.

class Pet
{
    public string Name { get; set; }
    public bool Vaccinated { get; set; }
}

public static void CountEx2()
{
    Pet[] pets = { new Pet { Name="Barley", Vaccinated=true },
                   new Pet { Name="Boots", Vaccinated=false },
                   new Pet { Name="Whiskers", Vaccinated=false } };

    try
    {
        int numberUnvaccinated = pets.Count(p => p.Vaccinated == false);
        Console.WriteLine("There are {0} unvaccinated animals.", numberUnvaccinated);
    }
    catch (OverflowException)
    {
        Console.WriteLine("The count is too large to store as an Int32.");
        Console.WriteLine("Try using the LongCount() method instead.");
    }
}

// This code produces the following output:
//
// There are 2 unvaccinated animals.

 

 

 

 

---

 

숫자 값 시퀀스의 평균을 계산합니다.

Average

Average(source)

반환
시퀀스 값의 평균을 반환하지만,
값 시퀀스의 평균이거나 소스 시퀀스가 비어 있거나 null 값만 포함하는 경우 null입니다.

 

 

기본

long?[] longs = { null, 10007L, 37L, 399846234235L };

double? average = longs.Average();

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:
//
// The average is 133282081426.333.

 

 

대리자를 통한 집계

string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

double average = fruits.Average(s => s.Length);

Console.WriteLine("The average string length is {0}.", average);

// This code produces the following output:
//
// The average string length is 6.5.




string[] numbers = { "10007", "37", "299846234235" };

double average = numbers.Average(num => long.Parse(num));

Console.WriteLine("The average is {0}.", average);

// This code produces the following output:
//
// The average is 99948748093.

 

---

요소에 특정 요소가 포함됐는지 확인하는

Contains

* 기본 같음 비교자를 사용하여 시퀀스에 지정된 요소가 들어 있는지 확인합니다.

반환
Boolean
소스 시퀀스에 지정된 값을 갖는 요소가 들어 있으면 true이고, 그렇지 않으면 false입니다.
예외
ArgumentNullExceptionsource이(가) null인 경우

 

 

*시퀀스 요소 내에 "mango" 가 존재하는지 판단하는 구문

string[] fruits = { "apple", "banana", "mango", "orange", "passionfruit", "grape" };

string fruit = "mango";

bool hasMango = fruits.Contains(fruit);

Console.WriteLine(
    "The array {0} contain '{1}'.",
    hasMango ? "does" : "does not",
    fruit);

// This code produces the following output:
//
// The array does contain 'mango'.

 

 

*기본 같음 비교자를 정의하는 방법도 존재

https://learn.microsoft.com/ko-kr/dotnet/api/system.linq.enumerable.contains?view=net-8.0

---

시퀀스의 모든 요소가 특정 조건에 맞는지 확인하는

All

public static bool
All<TSource> (
this
System.Collections.Generic.IEnumerable<TSource> source,
Func<TSource,bool> predicate);

* 주어진 모든 데이터가 predicate 의 값이 true 인 경우 true를 반환, 그렇지 않으면 false 를 반환

source : 데이터
predicate : Tsource를 받아 정해진 조건에 맞는 경우 bool을 반환하는 대리자

예외
ArgumentNullExceptionsource이(가) null인 경우

 

 

*모든 문자열의 시작이 B인 경우 allStartWithB  = True 가 됌.

bool allStartWithB = pets.All(pet =>
                                      pet.Name.StartsWith("B"));

 

 

* 모든 pet.Age가 5 이상인 경우 True 가 됌

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Person
{
    public string LastName { get; set; }
    public Pet[] Pets { get; set; }
}

public static void AllEx2()
{
    List<Person> people = new List<Person>
        { new Person { LastName = "Haas",
                       Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
                                          new Pet { Name="Boots", Age=14 },
                                          new Pet { Name="Whiskers", Age=6 }}},
          new Person { LastName = "Fakhouri",
                       Pets = new Pet[] { new Pet { Name = "Snowball", Age = 1}}},
          new Person { LastName = "Antebi",
                       Pets = new Pet[] { new Pet { Name = "Belle", Age = 8} }},
          new Person { LastName = "Philips",
                       Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
                                          new Pet { Name = "Rover", Age = 13}} }
        };

    // Determine which people have pets that are all older than 5.
    IEnumerable<string> names = from person in people
                                where person.Pets.All(pet => pet.Age > 5)
                                select person.LastName;

    foreach (string name in names)
    {
        Console.WriteLine(name);
    }

    /* This code produces the following output:
     *
     * Haas
     * Antebi
     */
}

 

 

 

---

시퀀스에 요소가 하나라도 조건에 맞는 요소가 있는지 확인하는

Any

public static bool  Any<TSource> (
this System.Collections.Generic.IEnumerable<TSource> source);

*소스에 요소가 존재하면 무조건 True, 공백이면 False

예외
ArgumentNullExceptionsource이(가) null인 경우

 

 

 

*numbers 가 비어있는지 확인

List<int> numbers = new List<int> { 1, 2 };
bool hasElements = numbers.Any();

Console.WriteLine("The list {0} empty.",
    hasElements ? "is not" : "is");

// This code produces the following output:
//
// The list is not empty.

---

 

* 애완동물이 하나라도 있는 경우 이름을 저장한다.

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Person
{
    public string LastName { get; set; }
    public Pet[] Pets { get; set; }
}

public static void AnyEx2()
{
    List<Person> people = new List<Person>
        { new Person { LastName = "Haas",
                       Pets = new Pet[] { new Pet { Name="Barley", Age=10 },
                                          new Pet { Name="Boots", Age=14 },
                                          new Pet { Name="Whiskers", Age=6 }}},
          new Person { LastName = "Fakhouri",
                       Pets = new Pet[] { new Pet { Name = "Snowball", Age = 1}}},
          new Person { LastName = "Antebi",
                       Pets = new Pet[] { }},
          new Person { LastName = "Philips",
                       Pets = new Pet[] { new Pet { Name = "Sweetie", Age = 2},
                                          new Pet { Name = "Rover", Age = 13}} }
        };

    // Determine which people have a non-empty Pet array.
    IEnumerable<string> names = from person in people
                                where person.Pets.Any()
                                select person.LastName;

    foreach (string name in names)
    {
        Console.WriteLine(name);
    }

    /* This code produces the following output:

       Haas
       Fakhouri
       Philips
    */
}

 

LastName = "Antebi"는 Pet이 없기에, 선택이 되지 않음

 

---

시퀀스의 원하는 값을 누적하여 반환하는

 Aggregate

public static TResult 
Aggregate(
seed,
Func<TAccumulate,TSource,TAccumulate> func)



seed : 초기값
func : (누적값 , 소스값, 결과값) 누적값 , 소스값을 활용하여 값을 계산하고 결과값을 반환하고 반환된 값을 누적값에 적용한다.

예외
ArgumentNullExceptionsource, func 또는 resultSelector가 null인 경우

 

 

*2의 배수의 개수를 세아리는 구문

int[] ints = { 4, 8, 8, 3, 9, 0, 7, 8, 2 };

// Count the even numbers in the array, using a seed value of 0.
int numEven = ints.Aggregate(0, (total, next) =>
                                    next % 2 == 0 ? total + 1 : total);

Console.WriteLine("The number of even integers is: {0}", numEven);

// This code produces the following output:
//
// The number of even integers is: 6

ints.Aggregate(0, (total, next) =>
                                    next % 2 == 0 ? total + 1 : total);

0 : 초기값

next  : 소스값

total :  누적값

 

설명 : 현재 소스값 next 가 2의 배수이면 수를 세아림

 

 

*가장 긴 문자열을 고르는 구문

string[] fruits = { "apple", "mango", "orange", "passionfruit", "grape" };

// Determine whether any string in the array is longer than "banana".
string longestName =
    fruits.Aggregate("banana",
                    (longest, next) =>
                        next.Length > longest.Length ? next : longest,
    // Return the final result as an upper case string.
                    fruit => fruit.ToUpper());

Console.WriteLine(
    "The fruit with the longest name is {0}.",
    longestName);

// This code produces the following output:
//
// The fruit with the longest name is PASSIONFRUIT.

fruits.Aggregate("banana",
                    (longest, next) =>
                        next.Length > longest.Length ? next : longest,

banana : 초기값

longest :  누적값

next : 소스값

 

설명 : 누적값에 저장된 문자열의 길이가 다음 소스값 보다 작다면 소스값으로 string 교체가 이루어짐