.NET DateTime'dan milisaniye kesilir

Ben bir veritabanı saklanan değeri gelen bir istek bir zaman damgası karşılaştırmak çalışıyorum. SQL Server, elbette zamanında milisaniyede bir hassasiyet tutar ve bir .NET DateTime'a okunduğunda, bu milisaniyeyi içerir. Ancak sisteme gelen istek bu hassasiyeti sunmuyor, bu yüzden sadece milisaniyeyi düşürmem gerekiyor.

Bariz bir şeyi kaçırmış gibi hissediyorum, ama bunu yapmak için zarif bir yol bulamadım (C #).

Aşağıdaki, kesirli milisaniyeye sahip ve aynı zamanda Kind özelliğini (Yerel, Utc veya Tanımsız) koruyan bir DateTime için çalışacaktır.

DateTime dateTime = ... anything ...
dateTime = new DateTime(
    dateTime.Ticks - (dateTime.Ticks % TimeSpan.TicksPerSecond), 
    dateTime.Kind
    );

veya eşdeğeri ve daha kısa:

dateTime = dateTime.AddTicks( - (dateTime.Ticks % TimeSpan.TicksPerSecond));

Bu bir genişletme yönteminde genelleştirilebilir:

public static DateTime Truncate(this DateTime dateTime, TimeSpan timeSpan)
{
    if (timeSpan == TimeSpan.Zero) return dateTime; // Or could throw an ArgumentException
    if (dateTime == DateTime.MinValue || dateTime == DateTime.MaxValue) return dateTime; // do not modify "guard" values
    return dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks));
}

aşağıdaki gibi kullanılır:

dateTime = dateTime.Truncate(TimeSpan.FromMilliseconds(1)); // Truncate to whole ms
dateTime = dateTime.Truncate(TimeSpan.FromSeconds(1)); // Truncate to whole second
dateTime = dateTime.Truncate(TimeSpan.FromMinutes(1)); // Truncate to whole minute
...

var date = DateTime.Now;

date = new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);

İşte herhangi bir çözüme kısalmanızı sağlayacak bir önceki cevaba dayanan bir uzatma yöntemi ...

Kullanımı:

DateTime myDateSansMilliseconds = myDate.Truncate(TimeSpan.TicksPerSecond);
DateTime myDateSansSeconds = myDate.Truncate(TimeSpan.TicksPerMinute)

Sınıf:

public static class DateTimeUtils
{
    /// <summary>
    /// <para>Truncates a DateTime to a specified resolution.</para>
    /// <para>A convenient source for resolution is TimeSpan.TicksPerXXXX constants.</para>
    /// </summary>
    /// <param name="date">The DateTime object to truncate</param>
    /// <param name="resolution">e.g. to round to nearest second, TimeSpan.TicksPerSecond</param>
    /// <returns>Truncated DateTime</returns>
    public static DateTime Truncate(this DateTime date, long resolution)
    {
        return new DateTime(date.Ticks - (date.Ticks % resolution), date.Kind);
    }
}

DateTime d = DateTime.Now;
d = d.AddMilliseconds(-d.Millisecond);

Bazen yıl veya ay gibi takvim tabanlı bir şeye kısaltmak istersiniz. İşte herhangi bir çözünürlük seçmenize izin veren bir uzantı yöntemi.

public enum DateTimeResolution
{
    Year, Month, Day, Hour, Minute, Second, Millisecond, Tick
}

public static DateTime Truncate(this DateTime self, DateTimeResolution resolution = DateTimeResolution.Second)
{
    switch (resolution)
    {
        case DateTimeResolution.Year:
            return new DateTime(self.Year, 1, 1, 0, 0, 0, 0, self.Kind);
        case DateTimeResolution.Month:
            return new DateTime(self.Year, self.Month, 1, 0, 0, 0, self.Kind);
        case DateTimeResolution.Day:
            return new DateTime(self.Year, self.Month, self.Day, 0, 0, 0, self.Kind);
        case DateTimeResolution.Hour:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerHour));
        case DateTimeResolution.Minute:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerMinute));
        case DateTimeResolution.Second:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerSecond));
        case DateTimeResolution.Millisecond:
            return self.AddTicks(-(self.Ticks % TimeSpan.TicksPerMillisecond));
        case DateTimeResolution.Tick:
            return self.AddTicks(0);
        default:
            throw new ArgumentException("unrecognized resolution", "resolution");
    }
}

Milisaniyeyi düşürüp karşılaştırmak yerine, farkı neden karşılaştırmıyorsunuz?

DateTime x; DateTime y;
bool areEqual = (x-y).TotalSeconds == 0;

veya

TimeSpan precision = TimeSpan.FromSeconds(1);
bool areEqual = (x-y).Duration() < precision;

Daha az belirgin ancak 2 kat daha hızlı:

// 10000000 runs

DateTime d = DateTime.Now;

// 484,375ms
d = new DateTime((d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

// 1296,875ms
d = d.AddMilliseconds(-d.Millisecond);

İkinciye yuvarlamak için:

dateTime.AddTicks(-dateTime.Ticks % TimeSpan.TicksPerSecond)

Dakikaya TicksPerMinuteyuvarlamak için ile değiştirin .

Kodunuz performansa duyarlıysa,

new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second)

Uygulamam CPU zamanının% 12'sini System.DateTime.GetDatePart'ta harcıyordu .

Kolay okuma için bir yol ...

//Remove milliseconds
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH:mm:ss"), "yyyy-MM-dd HH:mm:ss", null);

Ve dahası...

//Remove seconds
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH:mm"), "yyyy-MM-dd HH:mm", null);

//Remove minutes
DateTime date = DateTime.Now;
date = DateTime.ParseExact(date.ToString("yyyy-MM-dd HH"), "yyyy-MM-dd HH", null);

//and go on...

Diadistis yanıtı ile ilgili. Bu benim için işe yaradı, ancak çarpmadan önce bölümün kesirli kısmını kaldırmak için Floor kullanmak zorundaydım. Yani,

d = new DateTime((d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

olur

d = new DateTime(Math.Floor(d.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);

İki Uzun değerin bölünmesinin bir Uzun ile sonuçlanmasını ve böylece ondalık kısmı kaldırmasını beklerdim, ancak çarpma işleminden sonra tam olarak aynı değeri bırakarak bir Çift olarak çözer.

Eppsy

2 Yukarıda belirtilen çözümler için genişletme yöntemleri

    public static bool LiesAfterIgnoringMilliseconds(this DateTime theDate, DateTime compareDate, DateTimeKind kind)
    {
        DateTime thisDate = new DateTime(theDate.Year, theDate.Month, theDate.Day, theDate.Hour, theDate.Minute, theDate.Second, kind);
        compareDate = new DateTime(compareDate.Year, compareDate.Month, compareDate.Day, compareDate.Hour, compareDate.Minute, compareDate.Second, kind);

        return thisDate > compareDate;
    }


    public static bool LiesAfterOrEqualsIgnoringMilliseconds(this DateTime theDate, DateTime compareDate, DateTimeKind kind)
    {
        DateTime thisDate = new DateTime(theDate.Year, theDate.Month, theDate.Day, theDate.Hour, theDate.Minute, theDate.Second, kind);
        compareDate = new DateTime(compareDate.Year, compareDate.Month, compareDate.Day, compareDate.Hour, compareDate.Minute, compareDate.Second, kind);

        return thisDate >= compareDate;
    }

kullanımı:

bool liesAfter = myObject.DateProperty.LiesAfterOrEqualsIgnoringMilliseconds(startDateTime, DateTimeKind.Utc);

En hızlı çözüm değil, basit ve anlaşılması kolay:

DateTime d = DateTime.Now;
d = d.Date.AddHours(d.Hour).AddMinutes(d.Minute).AddSeconds(d.Second)

DateID.Text = DateTime.Today.ToShortDateString();

Use ToShortDateString() //Date 2-02-2016
Use ToShortDateString() // Time 

Ve Kullanarak

ToLongDateString() // its show 19 February 2016.

: P

Yeni Yöntem

String Date = DateTime.Today.ToString("dd-MMM-yyyy"); 

// string pass parametresini tanımla dd-mmm-yyyy return 24-feb-2016

Veya metin kutusunda gösterilir

txtDate.Text = DateTime.Today.ToString("dd-MMM-yyyy");

// PageonLoad'u tak

Benim durumumda, saniye ve milisaniyeyi kaydetmeden datetimePicker aracından TimeSpan'ı kurtarmayı hedefliyordum ve işte çözüm.

İlk önce datetimePicker.value değerini istediğiniz biçime dönüştürün; benimki "SS: dd", ardından TimeSpan'a geri dönüştürün.

var datetime = datetimepicker1.Value.ToString("HH:mm");
TimeSpan timeSpan = Convert.ToDateTime(datetime).TimeOfDay;

Bu, burada ve benzer sorularda yayınlanan uzantı yöntemlerinin versiyonum. Bu, keneler değerini kolay okunur bir şekilde doğrular ve özgün DateTime örneğinin DateTimeKind değerini korur. (Bunun MongoDB gibi bir veritabanında saklarken ince ama alakalı yan etkileri vardır.)

Gerçek hedef, bir DateTime değerini belirtilen bir değere (yani Saat / Dakika / Saniye / MS) kısaltmaksa, bunun yerine kodunuza bu uzantı yöntemini uygulamanızı öneririm. Yalnızca geçerli bir kesinliğe göre kısaltabilmenizi sağlar ve orijinal örneğinizin önemli DateTimeKind meta verilerini korur:

public static DateTime Truncate(this DateTime dateTime, long ticks)
{
    bool isValid = ticks == TimeSpan.TicksPerDay 
        || ticks == TimeSpan.TicksPerHour 
        || ticks == TimeSpan.TicksPerMinute 
        || ticks == TimeSpan.TicksPerSecond 
        || ticks == TimeSpan.TicksPerMillisecond;

    // /programming/21704604/have-datetime-now-return-to-the-nearest-second
    return isValid 
        ? DateTime.SpecifyKind(
            new DateTime(
                dateTime.Ticks - (dateTime.Ticks % ticks)
            ),
            dateTime.Kind
        )
        : throw new ArgumentException("Invalid ticks value given. Only TimeSpan tick values are allowed.");
}

Sonra bu yöntemi kullanabilirsiniz:

DateTime dateTime = DateTime.UtcNow.Truncate(TimeSpan.TicksPerMillisecond);

dateTime.Kind => DateTimeKind.Utc

Cevabın çok geç olduğunu biliyorum, ancak milisaniyeden kurtulmanın en iyi yolu

var currentDateTime = DateTime.Now.ToString("s");

Değişkenin değerini yazdırmayı deneyin, milisaniye olmadan tarih saatini gösterecektir.