Tarihler için Math.Min ve Math.Max ​​eşdeğeridir?

İki tarih arasında Min (veya Maks) değerini almanın en hızlı ve en kolay yolu nedir? Tarihler için Math.Min (& Math.Max) eşdeğeri var mı?

Gibi bir şey yapmak istiyorum:

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

Açıkçası yukarıdaki Math.Min çalışmıyor çünkü tarihler.

DateTime değerleri için aşırı yük yoktur, ancak Ticksdeğerlerin içerdiği uzun değeri alabilir , karşılaştırabilir ve sonuçtan yeni bir DateTime değeri oluşturabilirsiniz:

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

(DateTime yapısının da Kindyeni değerde tutulmayan bir özellik içerdiğini unutmayın . Bu normalde bir sorun değildir; Farklı türde DateTime değerlerini karşılaştırırsanız karşılaştırma yine de mantıklı değildir.)

Bunu yapmak için yerleşik bir yöntem yoktur. Şu ifadeyi kullanabilirsiniz:

(date1 > date2 ? date1 : date2)

ikisinin maksimumunu bulmak için.

Hesaplamak için Minveya Maxherhangi bir tür için ( Comparer<T>.Defaultuygun şekilde ayarlanması koşuluyla) genel bir yöntem yazabilirsiniz :

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

LINQ'yu da kullanabilirsiniz:

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

Nasıl olur:

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

IComparable<T>Veya özelliğini destekleyen herhangi bir türle çalışır IComparable.

Aslında, LINQ ile başka bir alternatif:

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

Bu, tarihlerin farklı 'türlere' sahip olmasını sağlar ve iletilen örneği döndürür (Keneler veya Milisaniyelerden oluşturulmuş yeni bir DateTime döndürmez).

[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);
    }

Bu testin Greenwich'in doğusunda başarısız olacağını unutmayın ...

Linq.Min()/ Linq.Max()yaklaşım:

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(); 

Daha çok Math.Max ​​gibi aramak istiyorsanız, bu çok kısa ifade gövdesi gibi bir şey yapabilirsiniz:

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

Bir DateTimeuzantı yöntemine ne dersiniz ?

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

Kullanımı:

var maxDate = date1.MaxOf(date2);

Artık LINQ'muz olduğuna göre, iki değerinizle (DateTimes, TimeSpans, ne olursa olsun) bir dizi oluşturabilir ve sonra .Max () uzantı yöntemini kullanabilirsiniz.

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

Güzel okuyor, Max olabildiğince verimli ve 2'den fazla karşılaştırma değeri için tekrar kullanılabilir.

Aşağıdaki sorun .Kind hakkında endişelenmek büyük bir anlaşma ... ama ben asla yerel zamanlarda, hiç çalışarak bunu önlemek. Zamanlarla ilgili önemli bir şeyim varsa, oraya gitmek için daha fazla iş anlamına gelse bile her zaman UTC'de çalışıyorum.

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