Equivalente de Math.Min e Math.Max ​​para datas?

Qual é a maneira mais rápida e fácil de obter o valor mínimo (ou máximo) entre duas datas? Existe um equivalente a Math.Min (& Math.Max) para datas?

Eu quero fazer algo como:

 if (Math.Min(Date1, Date2) < MINIMUM_ALLOWED_DATE) {
      //not allowed to do this
 }

Obviamente, o Math.Min acima não funciona porque são datas.

Não há sobrecarga para os valores DateTime, mas você pode obter o valor longo Ticksque é o que os valores contêm, compará-los e criar um novo valor DateTime a partir do resultado:

new DateTime(Math.Min(Date1.Ticks, Date2.Ticks))

(Observe que a estrutura DateTime também contém uma Kindpropriedade que não é mantida no novo valor. Isso normalmente não é um problema; se você comparar valores DateTime de tipos diferentes, a comparação não fará sentido de qualquer maneira.)

Não existe um método incorporado para fazer isso. Você pode usar a expressão:

(date1 > date2 ? date1 : date2)

para encontrar o máximo dos dois.

Você pode escrever um método genérico para calcular Minou Maxpara qualquer tipo (desde que Comparer<T>.Defaultdefinido adequadamente):

public static T Max<T>(T first, T second) {
    if (Comparer<T>.Default.Compare(first, second) > 0)
        return first;
    return second;
}

Você também pode usar o LINQ:

new[]{date1, date2, date3}.Max()

E se:

public static T Min<T>(params T[] values)
{
    if (values == null) throw new ArgumentNullException("values");
    var comparer = Comparer<T>.Default;
    switch(values.Length) {
        case 0: throw new ArgumentException();
        case 1: return values[0];
        case 2: return comparer.Compare(values[0],values[1]) < 0
               ? values[0] : values[1];
        default:
            T best = values[0];
            for (int i = 1; i < values.Length; i++)
            {
                if (comparer.Compare(values[i], best) < 0)
                {
                    best = values[i];
                }
            }
            return best;
    }        
}
// overload for the common "2" case...
public static T Min<T>(T x, T y)
{
    return Comparer<T>.Default.Compare(x, y) < 0 ? x : y;
}

Funciona com qualquer tipo que suporte IComparable<T>ou IComparable.

Na verdade, com o LINQ, outra alternativa é:

var min = new[] {x,y,z}.Min();

public static class DateTool
{
    public static DateTime Min(DateTime x, DateTime y)
    {
        return (x.ToUniversalTime() < y.ToUniversalTime()) ? x : y;
    }
    public static DateTime Max(DateTime x, DateTime y)
    {
        return (x.ToUniversalTime() > y.ToUniversalTime()) ? x : y;
    }
}

Isso permite que as datas tenham 'tipos' diferentes e retorna a instância que foi passada (sem retornar um novo DateTime construído a partir de Ticks ou Milissegundos).

[TestMethod()]
    public void MinTest2()
    {
        DateTime x = new DateTime(2001, 1, 1, 1, 1, 2, DateTimeKind.Utc);
        DateTime y = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Local);

        //Presumes Local TimeZone adjustment to UTC > 0
        DateTime actual = DateTool.Min(x, y);
        Assert.AreEqual(x, actual);
    }

Observe que este teste falharia a leste de Greenwich ...

Linq.Min()/ Linq.Max()abordagem:

DateTime date1 = new DateTime(2000,1,1);
DateTime date2 = new DateTime(2001,1,1);

DateTime minresult = new[] { date1,date2 }.Min();
DateTime maxresult = new[] { date1,date2 }.Max(); 

Se você quiser chamá-lo mais como Math.Max, poderá fazer algo como esse corpo de expressão muito curta:

public static DateTime Max(params DateTime[] dates) => dates.Max();
[...]
var lastUpdatedTime = DateMath.Max(feedItemDateTime, assemblyUpdatedDateTime);

Que tal um DateTimemétodo de extensão?

public static DateTime MaxOf(this DateTime instance, DateTime dateTime)
{
    return instance > dateTime ? instance : dateTime;
}

Uso:

var maxDate = date1.MaxOf(date2);

Agora que temos o LINQ, você pode criar uma matriz com seus dois valores (DateTimes, TimeSpans, qualquer que seja) e, em seguida, usar o método de extensão .Max ().

var values = new[] { Date1, Date2 }; 
var max = values.Max(); 

É bonito, é tão eficiente quanto o Max pode ser, e é reutilizável por mais de 2 valores de comparação.

Todo o problema abaixo se preocupar com .Kind é muito importante ... mas evito isso por nunca trabalhar nos horários locais. Se tenho algo importante em relação aos horários, sempre trabalho no UTC, mesmo que isso signifique mais trabalho para chegar lá.

// Two different dates
var date1 = new Date(2013, 05, 13); 
var date2 = new Date(2013, 04, 10) ;
// convert both dates in milliseconds and use Math.min function
var minDate = Math.min(date1.valueOf(), date2.valueOf());
// convert minDate to Date
var date = new Date(minDate); 

http://jsfiddle.net/5CR37/