DateTimeOffset當天比較

Question

我遇到了以下需求的有趣問題： 測試過程是否在同一天運行，如果不運行該過程。日期存儲爲DataTimeOffset。

我最初的做法是：

1. 都轉換值UTC，因爲可能在不同的時區中創建這些日期，並有不同的偏移。
2. 查看每個值的日期值。這是在轉換爲UTC後完成的，因爲Date方法會忽略偏移量。

大多數情況下，這工作，但我遇到了一種情況下，邏輯會失敗。如果其中一個值的時間接近前一天/第二天，以便轉換爲UTC時它將更改日期。如果其他值沒有時間也轉換爲前一天/下一天，則日期比較失敗。

所以我結束了以下邏輯包括情景：

public static bool SameDate(DateTimeOffset first, DateTimeOffset second) 
{ 
    bool returnValue = false; 
    DateTime firstAdjusted = first.ToUniversalTime().Date; 
    DateTime secondAdjusted = second.ToUniversalTime().Date; 

    // If date is now a day ahead after conversion, than add/deduct a day to other date if that date hasn't advanced 
    if (first.Date < firstAdjusted.Date && second.Date == secondAdjusted.Date) 
     secondAdjusted = secondAdjusted.Date.AddDays(1); 
    if (first.Date > firstAdjusted.Date && second.Date == secondAdjusted.Date) 
     secondAdjusted = secondAdjusted.Date.AddDays(-1); 

    if (second.Date < secondAdjusted.Date && first.Date == firstAdjusted.Date) 
     firstAdjusted = firstAdjusted.Date.AddDays(1); 
    if (second.Date > secondAdjusted.Date && first.Date == firstAdjusted.Date) 
     firstAdjusted = firstAdjusted.Date.AddDays(-1); 

    if (DateTime.Compare(firstAdjusted, secondAdjusted) == 0) 
     returnValue = true; 

    return returnValue; 
} 

這裏是被失敗的，現在通過單元測試：

[TestMethod()] 
public void SameDateTest() 
{ 
DateTimeOffset current = DateTimeOffset.Now; 
DateTimeOffset first = current; 
DateTimeOffset second = current; 

// 23 hours later, next day, with negative offset (EST) -- First rolls over 
first = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
second = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
Assert.IsFalse(Common.SameDate(first, second)); 

// 23 hours earlier, next day, with postive offset -- First rollovers 
first = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
second = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
Assert.IsFalse(Common.SameDate(first, second)); 

// 23 hours later, next day, with negative offset (EST) -- Second rolls over 
first = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
second = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
Assert.IsFalse(Common.SameDate(first, second)); 

// 23 hours earlier, next day, with postive offset -- Second rolls over 
first = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
second = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
Assert.IsFalse(Common.SameDate(first, second)); 
} 

我的直覺是，有比基於其他值的遞增/遞減更清潔的方法。有更好的方法嗎？

的主要標準：

1. 調整兩個日期爲具有相同的偏移量。
2. 只有在第一個和第二個日期都在同一日曆日內發生，而不是在24小時內才返回true。

Answer 1

調整日期在兩個日期之差的一個：

public static bool SameDate(DateTimeOffset first, DateTimeOffset second) 
{ 
    bool returnValue = false; 
    DateTime firstAdjusted = first.ToUniversalTime().Date; 
    DateTime secondAdjusted = second.ToUniversalTime().Date; 

    // calculate the total diference between the dates 
    int diff = first.Date.CompareTo(firstAdjusted) - second.Date.CompareTo(secondAdjusted); 
    // the firstAdjusted date is corected for the difference in BOTH dates. 
    firstAdjusted = firstAdjusted.AddDays(diff); 

    if (DateTime.Compare(firstAdjusted, secondAdjusted) == 0) 
     returnValue = true; 

    return returnValue; 
} 

在這個函數中，我asuming的偏移量將不會超過24小時。 IE日期和它的調整日期之間的區別不會是兩天或更多天。如果情況並非如此，那麼可以使用time span進行比較。

Answer 2

您描述的一般方法（轉換爲常見時區，然後比較日期部分）是合理的。這裏的問題實際上是決定參照系的一個問題。你有任意選擇UTC作爲你的參照系。一開始，只要將它們在相同的時區中進行比較，則無關緊要，但正如您發現這可以將它們放在一天的邊界的任一側。

我認爲您需要完善您的規範。問問你自己試圖確定下列哪一項。

• 該值是否出現在指定時區的同一天日曆天。
• 值是否不超過12小時（+/- 12小時是24小時）。
• 這些值是否不超過24小時。

也可能是別的。實施（但被您拒絕）的定義是「值是否出現在同一UTC日曆日」。

Answer 3

首先，您在UnitTest中出現錯誤。

[TestMethod()] 
    public void SameDateTest() 
    { 
     DateTimeOffset current = DateTimeOffset.Now; 
     DateTimeOffset first = current; 
     DateTimeOffset second = current; 

     // 23 hours later, next day, with negative offset (EST) -- First rolls over 
     first = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
     Assert.IsTrue(DateTimeComparison.Program.SameDate(first, second)); 

     // 23 hours earlier, next day, with positive offset -- First rollovers 
     first = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
     Assert.IsFalse(DateTimeComparison.Program.SameDate(first, second)); 

     // 23 hours later, next day, with negative offset (EST) -- Second rolls over 
     first = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
     Assert.IsTrue(DateTimeComparison.Program.SameDate(first, second)); 

     // 23 hours earlier, next day, with positive offset -- Second rolls over 
     first = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
     Assert.IsFalse(DateTimeComparison.Program.SameDate(first, second)); 
    } 

這是校正後的測試。你的第一次測試應該返回「真實」，就像你的第三次測試一樣。被比較的那些DateTimeOffset在相同的UTC日期。只有測試用例2和4應該返回「False」，因爲這些DateTimeOffset事實上在2個不同的日期。

其次，您可以簡化SameDate()功能如下：

public static bool SameDate(DateTimeOffset first, DateTimeOffset second) 
    { 
     bool returnValue = false; 
     DateTime firstAdjusted = first.UtcDateTime; 
     DateTime secondAdjusted = second.UtcDateTime; 

     if(firstAdjusted.Date == secondAdjusted.Date) 
      returnValue = true; 

     return returnValue; 
    } 

因爲所有你感興趣的是，如果first.Date和second.Date實際上是在同一個UTC日期，這將會把工作不需要額外做投射/轉換爲UTC。

第三，你可以用這個完整的程序測試你的測試用例：

using System; 

namespace DateTimeComparison 
{ 
    public class Program 
    { 
     static void Main(string[] args) 
     { 
      DateTimeOffset current = DateTimeOffset.Now; 
      DateTimeOffset first = current; 
      DateTimeOffset second = current; 

      // 23 hours later, next day, with negative offset (EST) -- First rolls over 
      first = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
      second = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
      if(false == SameDate(first, second)) { 
       Console.WriteLine("Different day values!"); 
      } else { 
       Console.WriteLine("Same day value!"); 
      } 

      // --Comment is wrong -- 23 hours earlier, next day, with positive offset -- First rollovers 
      first = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
      second = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
      if(false == SameDate(first, second)) { 
       Console.WriteLine("Different day values!"); 
      } else { 
       Console.WriteLine("Same day value!"); 
      } 

      // 23 hours later, next day, with negative offset (EST) -- Second rolls over 
      first = new DateTimeOffset(2014, 1, 2, 18, 0, 0, new TimeSpan(-5, 0, 0)); 
      second = new DateTimeOffset(2014, 1, 1, 19, 0, 0, new TimeSpan(-5, 0, 0)); 
      if(false == SameDate(first, second)) { 
       Console.WriteLine("Different day values!"); 
      } else { 
       Console.WriteLine("Same day value!"); 
      } 


      // --Comment is wrong -- 23 hours earlier, next day, with positive offset -- Second rolls over 
      first = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
      second = new DateTimeOffset(2014, 1, 1, 4, 0, 0, new TimeSpan(5, 0, 0)); 
      if(false == SameDate(first, second)) { 
       Console.WriteLine("Different day values!"); 
      } else { 
       Console.WriteLine("Same day value!"); 
      } 
     } 

     public static bool SameDate(DateTimeOffset first, DateTimeOffset second) 
     { 
      bool returnValue = false; 
      DateTime firstAdjusted = first.UtcDateTime; 
      DateTime secondAdjusted = second.UtcDateTime; 

      if(firstAdjusted.Date == secondAdjusted.Date) 
       returnValue = true; 

      return returnValue; 
     }   
    } 
} 

設置你喜歡的地方並運行調試這套短節目一個破發點。這會告訴你測試用例2和測試用例4實際上是UTC時間相隔2天以上，因此應該是錯誤的。此外，它將顯示測試用例1和測試用例3在相同的UTC日期，並且應該從正常運行的SameDate()期望真實。

如果你想你的第二個和第四個測試用例分開23小時在同一日期，然後測試情況下，兩個，你應該使用：

 // 23 hours earlier, next day, with positive offset -- First rollovers 
     first = new DateTimeOffset(2014, 1, 2, 4, 0, 0, new TimeSpan(5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 1, 5, 0, 0, new TimeSpan(5, 0, 0)); 
     Assert.IsTrue(DateTimeComparison.Program.SameDate(first, second)); 

而對於測試情況下爲四個，你應該使用：

 // 23 hours earlier, next day, with positive offset -- Second rolls over 
     first = new DateTimeOffset(2014, 1, 2, 5, 0, 0, new TimeSpan(5, 0, 0)); 
     second = new DateTimeOffset(2014, 1, 3, 4, 0, 0, new TimeSpan(5, 0, 0)); 
     Assert.IsTrue(DateTimeComparison.Program.SameDate(first, second)); 

Answer 4

怎麼樣這樣的功能：

public static bool SameDate(DateTimeOffset first, DateTimeOffset second) 
{ 
    return Math.Abs((first - second).TotalDays) < 1; 
} 

可以。減去兩個日期（DateTimeOff設置是聰明的，知道時區），它會給你一個範圍，一個時間跨度。然後你可以檢查這個範圍是否爲+ - 1天。

Answer 5

首先，你需要清楚一些混淆程序應該做什麼。對於兩個通用時區中的兩個通用時間戳（兩個DateTimeOffset實例沒有具體限制），不存在「日曆日」這樣的概念。每個時區都有其自己的日曆日。例如，我們可以有兩個實例DateTimeOffset，名爲first和second，它們有不同的偏移量。讓我們將時間軸可視化，並使用|__|標記DateTimeOffset實例引用的具體時間點與*和相應時區中的日曆日（即特定時區中0:00和23:59之間的時間間隔）。它看起來是這樣的：（2-3時之間）

first: ........|___________________*__|....... 
second: ...|______*_______________|............ 

當在first的時區，在second活動期間同日曆天發生的事情。當在second的時區中時，first事件發生在之後日曆日（上午1-2點之間）。

所以很明顯這個問題需要澄清，可能還有一點限制。那些真的是通用時區，還是他們在同一地點的時區，可能只在夏令時有所不同？在那種情況下，你爲什麼不忽略時區？例如。 2014年11月2日00:10至23:50之間，UTC偏移量已經發生變化（EDT-> ET），並且兩個時刻間隔超過24小時：new DateTimeOffset(2014, 11, 02, 00, 10, 00, new TimeSpan(-4, 0, 0)).Date == new DateTimeOffset(2014, 11, 02, 23, 50, 00, new TimeSpan(-5, 0, 0)).Date並不重要。基本上，這是martijn試圖做的，但是以一種非常複雜的方式。當你嘗試只是

public static bool SameDateSimple(DateTimeOffset first, DateTimeOffset second) 
{ 
    return first.Date == second.Date; 
} 

它會適用於所有上述單元測試。而且，這也是大多數人在保證兩個實例在一個地方提及時間的情況下稱爲「同一日曆日」的情況。或者，如果你真的比較兩個「隨機」時區，你必須選擇你的參考時區。最初嘗試時可能是UTC。或者，它可能是從人類的角度來看更符合邏輯使用第一時區爲基準（你也可以選擇第二個，它會得出不同的結果，但兩者的變體「一樣好」）：

public static bool SameDateGeneral(DateTimeOffset first, DateTimeOffset second) 
{ 
    DateTime secondAdjusted = second.ToOffset(first.Offset).Date; 
    return first.Date == secondAdjusted.Date; 
} 

這對於上述某些測試不起作用，但在某種意義上對於兩個隨機時區「正確」（在某種意義上）起作用更爲普遍：如果嘗試first = new DateTimeOffset(2014, 1, 2, 0, 30, 0, new TimeSpan(5, 0, 0)), second = new DateTimeOffset(2014, 1, 1, 23, 30, 0, new TimeSpan(4, 0, 0))，簡單SameDateSimple返回false（與martijn's一樣），即使這兩個實例在時間（都是2014-01-01 19:30: 00Z）中提及。 SameDateGeneral此處正確返回true。