C#

var max = input.OrderByDescending(s=> s.SecondsDiff).Max();

TheQFromDB GetItem = input.Max(ele=> ele.SecondsDiff);

Maciej Los wrote:

So, why do you try to loop through... one element?

TheQFromDB GetItem = input.First();
foreach (var item in input)

Maciej Los wrote:

TheQFromDB GetItem = input.Max(ele=> ele.SecondsDiff);

public static TResult Max<TSource,TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector);

public static TheQFromDB GetMaxWithLINQ (List<TheQFromDB> input)

public class Foo
{
    public double SecondsDifference { get; set; }
}

static void Main()
{
    List<Foo> foos = new List<Foo>
    {
        new Foo { SecondsDifference = 0 },
        new Foo { SecondsDifference = 42 },
        new Foo { SecondsDifference = 1 },
    };
    
    var max = foos.Max(f => f.SecondsDifference);
    Console.WriteLine(max.GetType()); // Output: System.Double
    Console.WriteLine(max); // Output: 42
}

public static TheQFromDB GetMaxWithLINQ (List<TheQFromDB> input)
       {
           return input.OrderByDescending(s=> s.SecondsDiff).First();
       }

public static TheQFromDB GetMaxWithLINQ (List<TheQFromDB> input)
       {
           var max = input.Max(s=> s.SecondsDiff);
           return input.Where(s=> s.SecondsDiff==max).First();
       }

public static TheQFromDB GetMaxWithLINQ (List<TheQFromDB> input)
        {
            
            var max = input.OrderByDescending(s => s.SecondsDiff).First();
            return max;
        }

public static TheQFromDB GetMax2 (List<TheQFromDB> input)
       {
           TheQFromDB GetItem = input.First();

           foreach (var item in input)
           {
               if (item.SecondsDiff > GetItem.SecondsDiff)
               {
                   GetItem = item;
               }
           }
           return GetItem;

public static TheQFromDB GetMax (List<TheQFromDB> input)
        {
            if (input == null || input.Count < 1)
                return null;

            int MaxIndex = input.Count - 1;
            for (int CurrentIndex = input.Count -2; CurrentIndex >=0; CurrentIndex--)
            {
                if (input[MaxIndex].SecondsDiff < input[CurrentIndex].SecondsDiff)
                    MaxIndex = CurrentIndex;
            }
            //Console.WriteLine("Max Value :" + input[MaxIndex].SecondsDiff);
            return input[MaxIndex];
        }

foreach (var item in input)
{
    maxValue =  Math.Max(maxValue, item.SecondsDiff);
}

public static TheQFromDB CalculateMaxVal (List<TheQFromDB> input)
   {
       double maxValue = double.MinValue;

       foreach (var item in input)
       {
           if (item.SecondsDiff > maxValue)
           {
               maxValue = item.SecondsDiff;
           }
       }

       Console.WriteLine(maxValue);
       return null;

   }

public static TheQFromDB CalculateMaxVal (List<TheQFromDB> input) {
       double maxValue = double.MinValue;
       TheQFromDb maxQ = null;

       foreach (var item in input) {
           if (item.SecondsDiff > maxValue) {
               maxValue = item.SecondsDiff;
               maxQ = item;
           }
       }

       Console.WriteLine(maxValue);

       return maxQ;
   }

public static TheQFromDB CalculateMaxVal(IEnumerable<TheQFromDB> input)
{
    TheQFromDB result = null;
    
    foreach (var item in input)
    {
        if (result == null || item.SecondsDiff > result.SecondsDiff)
        {
            result = item;
        }
    }
    
    Console.WriteLine(result?.SecondsDiff ?? double.MinValue);
    return result;
}

public static TheQFromDB CalculateMaxVal(IEnumerable<TheQFromDB> input)
{
    TheQFromDB result = null;
    
    foreach (var item in input)
    {
        if (result == null || item.SecondsDiff > result.SecondsDiff)
        {
            result = item;
        }
    }
    
    return result;
}

return result ?? new TheQFromDB();