Enumerable.OrderByDescending 메서드

정의

네임스페이스:: System.Linq

어셈블리:: System.Core.dll, System.Linq.dll

어셈블리:: netstandard.dll, System.Linq.dll

어셈블리:: System.Linq.dll

어셈블리:: System.Core.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

시퀀스의 요소를 내림차순으로 정렬합니다.

오버로드

Name	Description
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	지정된 비교자를 사용하여 시퀀스의 요소를 내림차순으로 정렬합니다.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	키에 따라 시퀀스의 요소를 내림차순으로 정렬합니다.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

지정된 비교자를 사용하여 시퀀스의 요소를 내림차순으로 정렬합니다.

public:
generic <typename TSource, typename TKey>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IOrderedEnumerable<TSource> ^ OrderByDescending(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector, System::Collections::Generic::IComparer<TKey> ^ comparer);

public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer);

public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector, System.Collections.Generic.IComparer<TKey>? comparer);

static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> * System.Collections.Generic.IComparer<'Key> -> System.Linq.IOrderedEnumerable<'Source>

<Extension()>
Public Function OrderByDescending(Of TSource, TKey) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey), comparer As IComparer(Of TKey)) As IOrderedEnumerable(Of TSource)

형식 매개 변수

TSource

의 요소 형식입니다 source.

TKey

keySelector반환된 키의 형식입니다.

매개 변수

source: IEnumerable<TSource>

정렬할 값의 시퀀스입니다.

keySelector: Func<TSource,TKey>

요소에서 키를 추출하는 함수입니다.

comparer: IComparer<TKey>

IComparer<T> 키를 비교할 수 있는 항목입니다.

반품

IOrderedEnumerable<TSource>

IOrderedEnumerable<TElement> 해당 요소가 키에 따라 내림차순으로 정렬되는 요소입니다.

예외

ArgumentNullException

source 또는 keySelector .입니다 null.

예제

다음 코드 예제에서는 변환 함수와 사용자 지정 비교자를 사용하여 OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) 시퀀스의 요소를 내림차순으로 정렬하는 방법을 보여 줍니다.

/// <summary>
/// This IComparer class sorts by the fractional part of the decimal number.
/// </summary>
public class SpecialComparer : IComparer<decimal>
{
    /// <summary>
    /// Compare two decimal numbers by their fractional parts.
    /// </summary>
    /// <param name="d1">The first decimal to compare.</param>
    /// <param name="d2">The second decimal to compare.</param>
    /// <returns>1 if the first decimal's fractional part
    /// is greater than the second decimal's fractional part,
    /// -1 if the first decimal's fractional
    /// part is less than the second decimal's fractional part,
    /// or the result of calling Decimal.Compare()
    /// if the fractional parts are equal.</returns>
    public int Compare(decimal d1, decimal d2)
    {
        decimal fractional1, fractional2;

        // Get the fractional part of the first number.
        try
        {
            fractional1 = decimal.Remainder(d1, decimal.Floor(d1));
        }
        catch (DivideByZeroException)
        {
            fractional1 = d1;
        }
        // Get the fractional part of the second number.
        try
        {
            fractional2 = decimal.Remainder(d2, decimal.Floor(d2));
        }
        catch (DivideByZeroException)
        {
            fractional2 = d2;
        }

        if (fractional1 == fractional2)
            return Decimal.Compare(d1, d2);
        else if (fractional1 > fractional2)
            return 1;
        else
            return -1;
    }
}

public static void OrderByDescendingEx1()
{
    List<decimal> decimals =
        new List<decimal> { 6.2m, 8.3m, 0.5m, 1.3m, 6.3m, 9.7m };

    IEnumerable<decimal> query =
        decimals.OrderByDescending(num =>
                                       num, new SpecialComparer());

    foreach (decimal num in query)
    {
        Console.WriteLine(num);
    }
}

/*
 This code produces the following output:

 9.7
 0.5
 8.3
 6.3
 1.3
 6.2
*/

' This class provides a custom implementation
' of the IComparer.Compare() method.
Class SpecialComparer
    Implements IComparer(Of Decimal)
    ''' <summary>
    ''' Compare two decimal numbers by their fractional parts.
    ''' </summary>
    ''' <param name="d1">The first decimal to compare.</param>
    ''' <param name="d2">The second decimal to compare.</param>
    ''' <returns>1 if the first decimal's fractional part is greater than
    ''' the second decimal's fractional part,
    ''' -1 if the first decimal's fractional
    ''' part is less than the second decimal's fractional part,
    ''' or the result of calling Decimal.Compare()
    ''' if the fractional parts are equal.</returns>
    Function Compare(ByVal d1 As Decimal, ByVal d2 As Decimal) As Integer _
    Implements IComparer(Of Decimal).Compare

        Dim fractional1 As Decimal
        Dim fractional2 As Decimal

        ' Get the fractional part of the first number.
        Try
            fractional1 = Decimal.Remainder(d1, Decimal.Floor(d1))
        Catch ex As DivideByZeroException
            fractional1 = d1
        End Try

        ' Get the fractional part of the second number.
        Try
            fractional2 = Decimal.Remainder(d2, Decimal.Floor(d2))
        Catch ex As DivideByZeroException
            fractional2 = d2
        End Try

        If (fractional1 = fractional2) Then
            ' The fractional parts are equal, so compare the entire numbers.
            Return Decimal.Compare(d1, d2)
        ElseIf (fractional1 > fractional2) Then
            Return 1
        Else
            Return -1
        End If
    End Function
End Class

Sub OrderByDescendingEx1()
    ' Create a list of decimal values.
    Dim decimals As New List(Of Decimal)(New Decimal() _
                                     {6.2D, 8.3D, 0.5D, 1.3D, 6.3D, 9.7D})

    ' Order the elements of the list by passing
    ' in the custom IComparer class.
    Dim query As IEnumerable(Of Decimal) =
    decimals.OrderByDescending(Function(num) num,
                               New SpecialComparer())

    Dim output As New System.Text.StringBuilder
    For Each num As Decimal In query
        output.AppendLine(num)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' 9.7
' 0.5
' 8.3
' 6.3
' 1.3
' 6.2

설명

이 메서드는 지연된 실행을 사용하여 구현됩니다. 즉시 반환 값은 작업을 수행하는 데 필요한 모든 정보를 저장하는 개체입니다. 이 메서드가 나타내는 쿼리는 해당 GetEnumerator 메서드를 직접 호출하거나 C#의 foreach 또는 Visual Basic For Each 사용하여 개체가 열거될 때까지 실행되지 않습니다.

요소 자체의 값으로 시퀀스를 정렬하려면 x => x 대한 ID 함수(C#의 경우 Function(x) x 또는 Visual Basic keySelector)를 지정합니다.

이 메서드의 반환 형식인 형식 IOrderedEnumerable<TElement>을 확장하기 위해 두 메서드가 정의됩니다. 이러한 두 메서드, 즉 ThenByThenByDescending, 시퀀스를 정렬하는 추가 정렬 조건을 지정할 수 있습니다. ThenBy을 반환ThenByDescending합니다IOrderedEnumerable<TElement>. 즉, 연속 호출 ThenBy 의 수를 의미하거나 ThenByDescending 수행할 수 있습니다.

메모

IOrderedEnumerable<TElement> 에서 상속되므로 IEnumerable<T>호출 OrderBy 하거나 OrderByDescending 호출 OrderBy OrderByDescending ThenBy ThenByDescending결과 또는 . 이렇게 하면 이전에 설정된 순서를 무시하는 새 기본 순서가 도입됩니다.

이 comparer경우 null 기본 비교자를 Default 사용하여 키를 비교합니다.

이 메서드는 안정적인 정렬을 수행합니다. 즉, 두 요소의 키가 같으면 요소의 순서가 유지됩니다. 반면, 불안정한 정렬은 키가 같은 요소의 순서를 유지하지 않습니다.

추가 정보

적용 대상

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

Source:: OrderBy.cs

키에 따라 시퀀스의 요소를 내림차순으로 정렬합니다.

public:
generic <typename TSource, typename TKey>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IOrderedEnumerable<TSource> ^ OrderByDescending(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, TKey> ^ keySelector);

public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource,TKey>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,TKey> keySelector);

static member OrderByDescending : seq<'Source> * Func<'Source, 'Key> -> System.Linq.IOrderedEnumerable<'Source>

<Extension()>
Public Function OrderByDescending(Of TSource, TKey) (source As IEnumerable(Of TSource), keySelector As Func(Of TSource, TKey)) As IOrderedEnumerable(Of TSource)