Queryable.OrderByDescending<TSource, TKey> Method (IQueryable<TSource>, Expression<Func<TSource, TKey>>, IComparer<TKey>)

Type Parameters

• TSource
  The type of the elements of source.

• TKey
  The type of the key returned by the function that is represented by keySelector.

Parameters

• source
  Type: System.Linq.IQueryable<TSource>
  A sequence of values to order.

• keySelector
  Type: System.Linq.Expressions.Expression<Func<TSource, TKey>>
  A function to extract a key from an element.

• comparer
  Type: System.Collections.Generic.IComparer<TKey>
  An IComparer<T> to compare keys.

Return Value

Type: System.Linq.IOrderedQueryable<TSource>
An IOrderedQueryable<T> whose elements are sorted in descending order according to a key.

   ''' <summary>
   ''' This class provides a custom implementation of the
   ''' IComparer.Compare() method. It sorts by the fractional part of the decimal number.
   ''' </summary>
   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.AsQueryable(). _
          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.
      outputBlock.Text &= output.ToString() & vbCrLf
   End Sub

   ' This code produces the following output:

   ' 9.7
   ' 0.5
   ' 8.3
   ' 6.3
   ' 1.3
   ' 6.2

         /// <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 };

            // Sort the decimal values in descending order
            // by using a custom comparer.
            IEnumerable<decimal> query =
                decimals.AsQueryable()
                .OrderByDescending(num => num, new SpecialComparer());

            foreach (decimal num in query)
               outputBlock.Text += num + "\n";
         }

         /*
             This code produces the following output:

             9.7
             0.5
             8.3
             6.3
             1.3
             6.2
         */