Cách cắt bớt mili giây của .NET DateTime

Tôi đang cố gắng so sánh một dấu thời gian từ một yêu cầu đến với một giá trị được lưu trữ cơ sở dữ liệu. Tất nhiên, SQL Server giữ một số độ chính xác của mili giây và khi đọc vào .NET DateTime, nó bao gồm các mili giây đó. Tuy nhiên, yêu cầu đến hệ thống không cung cấp độ chính xác đó, vì vậy tôi chỉ cần giảm một phần nghìn giây.

Tôi cảm thấy như tôi đang thiếu một cái gì đó rõ ràng, nhưng tôi đã không tìm thấy một cách thanh lịch để làm điều đó (C #).

Phần sau sẽ hoạt động cho DateTime có mili giây, và cũng giữ nguyên thuộc tính Kind (Local, Utc hoặc Undinite).

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

hoặc tương đương và ngắn hơn:

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

Điều này có thể được khái quát thành một phương pháp mở rộng:

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

được sử dụng như sau:

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

Đây là một phương pháp mở rộng dựa trên câu trả lời trước đó sẽ cho phép bạn cắt ngắn mọi độ phân giải ...

Sử dụng:

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

Lớp học:

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

Đôi khi bạn muốn cắt ngắn một cái gì đó dựa trên lịch, như năm hoặc tháng. Đây là một phương pháp mở rộng cho phép bạn chọn bất kỳ độ phân giải.

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

Thay vì giảm mili giây sau đó so sánh, tại sao không so sánh sự khác biệt?

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

hoặc là

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

Ít rõ ràng hơn nhưng nhanh hơn 2 lần:

// 10000000 runs

DateTime d = DateTime.Now;

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

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

Để làm tròn xuống thứ hai:

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

Thay thế bằng TicksPerMinuteđể làm tròn xuống đến phút.

Nếu mã của bạn nhạy cảm với hiệu suất, hãy thận trọng về

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

Ứng dụng của tôi đã dành 12% thời gian CPU trong System.DateTime.GetDatePart .

Một cách để đọc dễ dàng là ...

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

Và hơn thế nữa...

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

Về phản ứng Diadistis. Điều này làm việc cho tôi, ngoại trừ tôi phải sử dụng Tầng để loại bỏ phần phân số của phép chia trước khi nhân. Vì thế,

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

trở thành

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

Tôi đã dự kiến ​​việc chia hai giá trị Long sẽ dẫn đến Long, do đó loại bỏ phần thập phân, nhưng nó giải quyết nó thành Double để lại cùng một giá trị sau khi nhân.

Eppsy

2 Phương pháp mở rộng cho các giải pháp được đề cập ở trên

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

sử dụng:

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

Không phải là giải pháp nhanh nhất nhưng đơn giản và dễ hiểu:

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 

Và bằng cách sử dụng

ToLongDateString() // its show 19 February 2016.

: P

Phương pháp mới

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

// xác định tham số truyền chuỗi dd-mmm-yyyy return 24-feb-2016

Hoặc hiển thị trên hộp văn bản

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

// đưa vào PageonLoad

Trong trường hợp của tôi, tôi đã nhắm đến việc lưu TimeSpan từ công cụ datetimePicker mà không lưu giây và mili giây, và đây là giải pháp.

Đầu tiên chuyển đổi datetimePicker.value sang định dạng mong muốn của bạn, cái của tôi là "HH: mm" sau đó chuyển đổi lại thành TimeSpan.

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

Đây là phiên bản của tôi về các phương pháp mở rộng được đăng ở đây và trong các câu hỏi tương tự. Điều này xác nhận giá trị tick theo cách dễ đọc và bảo tồn DateTimeKind của phiên bản DateTime ban đầu. (Điều này có tác dụng phụ tinh tế nhưng có liên quan khi lưu trữ vào cơ sở dữ liệu như MongoDB.)

Nếu mục tiêu thực sự là cắt ngắn DateTime thành một giá trị được chỉ định (ví dụ: Giờ / phút / giây / MS), tôi khuyên bạn nên triển khai phương thức tiện ích mở rộng này trong mã của mình. Nó đảm bảo rằng bạn chỉ có thể cắt ngắn đến độ chính xác hợp lệ và nó bảo tồn siêu dữ liệu DateTimeKind quan trọng của thể hiện ban đầu của bạn:

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.");
}

Sau đó, bạn có thể sử dụng phương pháp như thế này:

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

dateTime.Kind => DateTimeKind.Utc

Tôi biết câu trả lời là khá muộn, nhưng cách tốt nhất để thoát khỏi mili giây là

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

Hãy thử in giá trị của biến, nó sẽ hiển thị thời gian ngày, không có mili giây.