Calculate relative time in C#

后端 未结 30 2184
生来不讨喜
生来不讨喜 2020-11-21 05:59

Given a specific DateTime value, how do I display relative time, like:

  • 2 hours ago
  • 3 days ago
  • a month ago
相关标签:
30条回答
  • 2020-11-21 06:18
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    public static class RelativeDateHelper
    {
        private static Dictionary<double, Func<double, string>> sm_Dict = null;
    
        private static Dictionary<double, Func<double, string>> DictionarySetup()
        {
            var dict = new Dictionary<double, Func<double, string>>();
            dict.Add(0.75, (mins) => "less than a minute");
            dict.Add(1.5, (mins) => "about a minute");
            dict.Add(45, (mins) => string.Format("{0} minutes", Math.Round(mins)));
            dict.Add(90, (mins) => "about an hour");
            dict.Add(1440, (mins) => string.Format("about {0} hours", Math.Round(Math.Abs(mins / 60)))); // 60 * 24
            dict.Add(2880, (mins) => "a day"); // 60 * 48
            dict.Add(43200, (mins) => string.Format("{0} days", Math.Floor(Math.Abs(mins / 1440)))); // 60 * 24 * 30
            dict.Add(86400, (mins) => "about a month"); // 60 * 24 * 60
            dict.Add(525600, (mins) => string.Format("{0} months", Math.Floor(Math.Abs(mins / 43200)))); // 60 * 24 * 365 
            dict.Add(1051200, (mins) => "about a year"); // 60 * 24 * 365 * 2
            dict.Add(double.MaxValue, (mins) => string.Format("{0} years", Math.Floor(Math.Abs(mins / 525600))));
    
            return dict;
        }
    
        public static string ToRelativeDate(this DateTime input)
        {
            TimeSpan oSpan = DateTime.Now.Subtract(input);
            double TotalMinutes = oSpan.TotalMinutes;
            string Suffix = " ago";
    
            if (TotalMinutes < 0.0)
            {
                TotalMinutes = Math.Abs(TotalMinutes);
                Suffix = " from now";
            }
    
            if (null == sm_Dict)
                sm_Dict = DictionarySetup();
    
            return sm_Dict.First(n => TotalMinutes < n.Key).Value.Invoke(TotalMinutes) + Suffix;
        }
    }
    

    The same as another answer to this question but as an extension method with a static dictionary.

    0 讨论(0)
  • 2020-11-21 06:21

    Java for client-side gwt usage:

    import java.util.Date;
    
    public class RelativeDateFormat {
    
     private static final long ONE_MINUTE = 60000L;
     private static final long ONE_HOUR = 3600000L;
     private static final long ONE_DAY = 86400000L;
     private static final long ONE_WEEK = 604800000L;
    
     public static String format(Date date) {
    
      long delta = new Date().getTime() - date.getTime();
      if (delta < 1L * ONE_MINUTE) {
       return toSeconds(delta) == 1 ? "one second ago" : toSeconds(delta)
         + " seconds ago";
      }
      if (delta < 2L * ONE_MINUTE) {
       return "one minute ago";
      }
      if (delta < 45L * ONE_MINUTE) {
       return toMinutes(delta) + " minutes ago";
      }
      if (delta < 90L * ONE_MINUTE) {
       return "one hour ago";
      }
      if (delta < 24L * ONE_HOUR) {
       return toHours(delta) + " hours ago";
      }
      if (delta < 48L * ONE_HOUR) {
       return "yesterday";
      }
      if (delta < 30L * ONE_DAY) {
       return toDays(delta) + " days ago";
      }
      if (delta < 12L * 4L * ONE_WEEK) {
       long months = toMonths(delta);
       return months <= 1 ? "one month ago" : months + " months ago";
      } else {
       long years = toYears(delta);
       return years <= 1 ? "one year ago" : years + " years ago";
      }
     }
    
     private static long toSeconds(long date) {
      return date / 1000L;
     }
    
     private static long toMinutes(long date) {
      return toSeconds(date) / 60L;
     }
    
     private static long toHours(long date) {
      return toMinutes(date) / 60L;
     }
    
     private static long toDays(long date) {
      return toHours(date) / 24L;
     }
    
     private static long toMonths(long date) {
      return toDays(date) / 30L;
     }
    
     private static long toYears(long date) {
      return toMonths(date) / 365L;
     }
    
    }
    
    0 讨论(0)
  • 2020-11-21 06:22

    I thought I'd give this a shot using classes and polymorphism. I had a previous iteration which used sub-classing which ended up having way too much overhead. I've switched to a more flexible delegate / public property object model which is significantly better. My code is very slightly more accurate, I wish I could come up with a better way to generate "months ago" that didn't seem too over-engineered.

    I think I'd still stick with Jeff's if-then cascade because it's less code and it's simpler (it's definitely easier to ensure it'll work as expected).

    For the below code PrintRelativeTime.GetRelativeTimeMessage(TimeSpan ago) returns the relative time message (e.g. "yesterday").

    public class RelativeTimeRange : IComparable
    {
        public TimeSpan UpperBound { get; set; }
    
        public delegate string RelativeTimeTextDelegate(TimeSpan timeDelta);
    
        public RelativeTimeTextDelegate MessageCreator { get; set; }
    
        public int CompareTo(object obj)
        {
            if (!(obj is RelativeTimeRange))
            {
                return 1;
            }
            // note that this sorts in reverse order to the way you'd expect, 
            // this saves having to reverse a list later
            return (obj as RelativeTimeRange).UpperBound.CompareTo(UpperBound);
        }
    }
    
    public class PrintRelativeTime
    {
        private static List<RelativeTimeRange> timeRanges;
    
        static PrintRelativeTime()
        {
            timeRanges = new List<RelativeTimeRange>{
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromSeconds(1),
                    MessageCreator = (delta) => 
                    { return "one second ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromSeconds(60),
                    MessageCreator = (delta) => 
                    { return delta.Seconds + " seconds ago"; }
    
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromMinutes(2),
                    MessageCreator = (delta) => 
                    { return "one minute ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromMinutes(60),
                    MessageCreator = (delta) => 
                    { return delta.Minutes + " minutes ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromHours(2),
                    MessageCreator = (delta) => 
                    { return "one hour ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromHours(24),
                    MessageCreator = (delta) => 
                    { return delta.Hours + " hours ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.FromDays(2),
                    MessageCreator = (delta) => 
                    { return "yesterday"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = DateTime.Now.Subtract(DateTime.Now.AddMonths(-1)),
                    MessageCreator = (delta) => 
                    { return delta.Days + " days ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = DateTime.Now.Subtract(DateTime.Now.AddMonths(-2)),
                    MessageCreator = (delta) => 
                    { return "one month ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = DateTime.Now.Subtract(DateTime.Now.AddYears(-1)),
                    MessageCreator = (delta) => 
                    { return (int)Math.Floor(delta.TotalDays / 30) + " months ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = DateTime.Now.Subtract(DateTime.Now.AddYears(-2)),
                    MessageCreator = (delta) => 
                    { return "one year ago"; }
                }, 
                new RelativeTimeRange
                {
                    UpperBound = TimeSpan.MaxValue,
                    MessageCreator = (delta) => 
                    { return (int)Math.Floor(delta.TotalDays / 365.24D) + " years ago"; }
                }
            };
    
            timeRanges.Sort();
        }
    
        public static string GetRelativeTimeMessage(TimeSpan ago)
        {
            RelativeTimeRange postRelativeDateRange = timeRanges[0];
    
            foreach (var timeRange in timeRanges)
            {
                if (ago.CompareTo(timeRange.UpperBound) <= 0)
                {
                    postRelativeDateRange = timeRange;
                }
            }
    
            return postRelativeDateRange.MessageCreator(ago);
        }
    }
    
    0 讨论(0)
  • 2020-11-21 06:22

    I would provide some handy extensions methods for this and make the code more readable. First, couple of extension methods for Int32.

    public static class TimeSpanExtensions {
    
        public static TimeSpan Days(this int value) {
    
            return new TimeSpan(value, 0, 0, 0);
        }
    
        public static TimeSpan Hours(this int value) {
    
            return new TimeSpan(0, value, 0, 0);
        }
    
        public static TimeSpan Minutes(this int value) {
    
            return new TimeSpan(0, 0, value, 0);
        }
    
        public static TimeSpan Seconds(this int value) {
    
            return new TimeSpan(0, 0, 0, value);
        }
    
        public static TimeSpan Milliseconds(this int value) {
    
            return new TimeSpan(0, 0, 0, 0, value);
        }
    
        public static DateTime Ago(this TimeSpan value) {
    
            return DateTime.Now - value;
        }
    }
    

    Then, one for DateTime.

    public static class DateTimeExtensions {
    
        public static DateTime Ago(this DateTime dateTime, TimeSpan delta) {
    
            return dateTime - delta;
        }
    }
    

    Now, you can do something like below:

    var date = DateTime.Now;
    date.Ago(2.Days()); // 2 days ago
    date.Ago(7.Hours()); // 7 hours ago
    date.Ago(567.Milliseconds()); // 567 milliseconds ago
    
    0 讨论(0)
  • 2020-11-21 06:23
    public static string ToRelativeDate(DateTime input)
    {
        TimeSpan oSpan = DateTime.Now.Subtract(input);
        double TotalMinutes = oSpan.TotalMinutes;
        string Suffix = " ago";
    
        if (TotalMinutes < 0.0)
        {
            TotalMinutes = Math.Abs(TotalMinutes);
            Suffix = " from now";
        }
    
        var aValue = new SortedList<double, Func<string>>();
        aValue.Add(0.75, () => "less than a minute");
        aValue.Add(1.5, () => "about a minute");
        aValue.Add(45, () => string.Format("{0} minutes", Math.Round(TotalMinutes)));
        aValue.Add(90, () => "about an hour");
        aValue.Add(1440, () => string.Format("about {0} hours", Math.Round(Math.Abs(oSpan.TotalHours)))); // 60 * 24
        aValue.Add(2880, () => "a day"); // 60 * 48
        aValue.Add(43200, () => string.Format("{0} days", Math.Floor(Math.Abs(oSpan.TotalDays)))); // 60 * 24 * 30
        aValue.Add(86400, () => "about a month"); // 60 * 24 * 60
        aValue.Add(525600, () => string.Format("{0} months", Math.Floor(Math.Abs(oSpan.TotalDays / 30)))); // 60 * 24 * 365 
        aValue.Add(1051200, () => "about a year"); // 60 * 24 * 365 * 2
        aValue.Add(double.MaxValue, () => string.Format("{0} years", Math.Floor(Math.Abs(oSpan.TotalDays / 365))));
    
        return aValue.First(n => TotalMinutes < n.Key).Value.Invoke() + Suffix;
    }
    

    http://refactormycode.com/codes/493-twitter-esque-relative-dates

    C# 6 version:

    static readonly SortedList<double, Func<TimeSpan, string>> offsets = 
       new SortedList<double, Func<TimeSpan, string>>
    {
        { 0.75, _ => "less than a minute"},
        { 1.5, _ => "about a minute"},
        { 45, x => $"{x.TotalMinutes:F0} minutes"},
        { 90, x => "about an hour"},
        { 1440, x => $"about {x.TotalHours:F0} hours"},
        { 2880, x => "a day"},
        { 43200, x => $"{x.TotalDays:F0} days"},
        { 86400, x => "about a month"},
        { 525600, x => $"{x.TotalDays / 30:F0} months"},
        { 1051200, x => "about a year"},
        { double.MaxValue, x => $"{x.TotalDays / 365:F0} years"}
    };
    
    public static string ToRelativeDate(this DateTime input)
    {
        TimeSpan x = DateTime.Now - input;
        string Suffix = x.TotalMinutes > 0 ? " ago" : " from now";
        x = new TimeSpan(Math.Abs(x.Ticks));
        return offsets.First(n => x.TotalMinutes < n.Key).Value(x) + Suffix;
    }
    
    0 讨论(0)
  • 2020-11-21 06:23

    You can use TimeAgo extension as below:

    public static string TimeAgo(this DateTime dateTime)
    {
        string result = string.Empty;
        var timeSpan = DateTime.Now.Subtract(dateTime);
     
        if (timeSpan <= TimeSpan.FromSeconds(60))
        {
            result = string.Format("{0} seconds ago", timeSpan.Seconds);
        }
        else if (timeSpan <= TimeSpan.FromMinutes(60))
        {
            result = timeSpan.Minutes > 1 ? 
                String.Format("about {0} minutes ago", timeSpan.Minutes) :
                "about a minute ago";
        }
        else if (timeSpan <= TimeSpan.FromHours(24))
        {
            result = timeSpan.Hours > 1 ? 
                String.Format("about {0} hours ago", timeSpan.Hours) : 
                "about an hour ago";
        }
        else if (timeSpan <= TimeSpan.FromDays(30))
        {
            result = timeSpan.Days > 1 ? 
                String.Format("about {0} days ago", timeSpan.Days) : 
                "yesterday";
        }
        else if (timeSpan <= TimeSpan.FromDays(365))
        {
            result = timeSpan.Days > 30 ? 
                String.Format("about {0} months ago", timeSpan.Days / 30) : 
                "about a month ago";
        }
        else
        {
            result = timeSpan.Days > 365 ? 
                String.Format("about {0} years ago", timeSpan.Days / 365) : 
                "about a year ago";
        }
     
        return result;
    }
    

    Or use jQuery plugin with Razor extension from Timeago.

    0 讨论(0)
提交回复
热议问题