Server Time Context in C#

ServerTime.cs

// ローカルのTimeZoneに依存しないTimeClass
using System;
using System.ComponentModel;

[TypeConverter(typeof(ServerTimeConverter))]
public struct ServerTime : IComparable, IComparable<ServerTime>, IEquatable<ServerTime>
{
  static DateTimeOffset timeContext;
  static TimeSpan offset;

  public static implicit operator ServerTime(String str)
  {
    return new ServerTime(DateTimeOffset.Parse(str));
  }

  public static implicit operator ServerTime (DateTimeOffset dateTime) {
    return new ServerTime(dateTime);
  }

  public static DateTimeOffset GetTime(DateTimeOffset time)
  {
    return timeContext;
  }

  public static void SetTime(DateTimeOffset time)
  {
    timeContext = time;
    offset = time.ToUniversalTime() - DateTimeOffset.UtcNow;
  }

  public static ServerTime Now
  {
    get { return new ServerTime(DateTimeOffset.Now + offset); }
  }

  public static ServerTime Parse(string s)
  {
    return new ServerTime(DateTimeOffset.Parse(s));
  }

  public static int Compare(ServerTime t1, ServerTime t2)
  {
    return DateTimeOffset.Compare(t1.DateTimeOffset, t2.DateTimeOffset);
  }

  public static string GetTimeText(int seconds)
  {
    if (seconds > 60 * 60 * 24) return Localization.Get("ServerTime.OverOneDay");
    if(seconds <= 0) return string.Format("{0}{1}", 1, Localization.Get("ServerTime.Sec")); // 0秒以下の場合は1秒と表示する.

    System.Text.StringBuilder sb = new System.Text.StringBuilder();

    int hours = seconds / (60 * 60);
    seconds %= (60 * 60);
    int minutes = seconds / 60;
    seconds %= 60;

    if (hours > 0)   sb.Append(string.Format("{0}{1}", hours,   Localization.Get("ServerTime.Hour")));
    if (minutes > 0) sb.Append(string.Format("{0}{1}", minutes, Localization.Get("ServerTime.Min")));
    if (hours == 0)  sb.Append(string.Format("{0}{1}", seconds, Localization.Get("ServerTime.Sec")));

    return sb.ToString();
  }

  public static bool operator ==(ServerTime t1, ServerTime t2)
  {
    if (System.Object.ReferenceEquals(t1, t2))
    {
      return true;
    }
    if (((object)t1 == null) || ((object)t2 == null))
    {
      return false;
    }
    return t1.DateTimeOffset == t2.DateTimeOffset;
  }

  public static bool operator !=(ServerTime t1, ServerTime t2)
  {
    return !(t1 == t2);
  }

  public static ServerTime operator +(ServerTime time, TimeSpan span)
  {
    return new ServerTime(time.DateTimeOffset + span);
  }

  public static ServerTime operator -(ServerTime time, TimeSpan span)
  {
    return new ServerTime(time.DateTimeOffset - span);
  }

  public static TimeSpan operator -(ServerTime t1, ServerTime t2)
  {
    return t1.DateTimeOffset - t2.DateTimeOffset;
  }

  public static bool operator >(ServerTime t1, ServerTime t2)
  {
    return t1.DateTimeOffset > t2.DateTimeOffset;
  }

  public static bool operator >=(ServerTime t1, ServerTime t2)
  {
    return t1.DateTimeOffset >= t2.DateTimeOffset;
  }

  public static bool operator <(ServerTime t1, ServerTime t2)
  {
    return t1.DateTimeOffset < t2.DateTimeOffset;
  }

  public static bool operator <=(ServerTime t1, ServerTime t2)
  {
    return t1.DateTimeOffset <= t2.DateTimeOffset;
  }

  public static bool CheckCheat(DateTimeOffset time, int permittedSecounds = 15)
  {
    TimeSpan currentOffset = time.ToUniversalTime() - DateTimeOffset.UtcNow;
    return Math.Abs((offset - currentOffset).TotalSeconds) > permittedSecounds;
  }

  public ServerTime(DateTimeOffset time)
  {
    this._dateTimeOffset = time;
  }

  private DateTimeOffset _dateTimeOffset;
  public DateTimeOffset DateTimeOffset
  {
    get { return _dateTimeOffset; }
    set { _dateTimeOffset = value; }
  }

  public DateTime Date { get { return DateTimeOffset.Date; } }

  public int Hour { get { return DateTimeOffset.Hour; } }

  public int Day { get { return DateTimeOffset.Day; } }

  public int Millisecond { get { return DateTimeOffset.Millisecond; } }

  public int Minute { get { return DateTimeOffset.Minute; } }

  public int Month { get { return DateTimeOffset.Month; } }

  public TimeSpan Offset { get { return DateTimeOffset.Offset; } }

  public int Second { get { return DateTimeOffset.Second; } }

  public long Ticks { get { return DateTimeOffset.Ticks; } }

  public int Year { get { return DateTimeOffset.Year; } }

  public ServerTime Add(TimeSpan timeSpan)
  {
    return new ServerTime(DateTimeOffset.Add(timeSpan));
  }

  public ServerTime AddDays(double days)
  {
    return new ServerTime(DateTimeOffset.AddDays(days));
  }

  public ServerTime AddHours(double hours)
  {
    return new ServerTime(DateTimeOffset.AddHours(hours));
  }

  public ServerTime AddMilliseconds(double milliseconds)
  {
    return new ServerTime(DateTimeOffset.AddMilliseconds(milliseconds));
  }

  public ServerTime AddMinutes(double minutes)
  {
    return new ServerTime(DateTimeOffset.AddMinutes(minutes));
  }

  public ServerTime AddMonths(int months)
  {
    return new ServerTime(DateTimeOffset.AddMonths(months));
  }

  public ServerTime AddSeconds(double seconds)
  {
    return new ServerTime(DateTimeOffset.AddSeconds(seconds));
  }

  public ServerTime AddTicks(long ticks)
  {
    return new ServerTime(DateTimeOffset.AddTicks(ticks));
  }

  public ServerTime AddYears(int years)
  {
    return new ServerTime(DateTimeOffset.AddYears(years));
  }


  int IComparable.CompareTo(System.Object obj) {
    if (obj == null) return 1;
    if (!(obj is ServerTime)) {
      throw new ArgumentException("MustBeServerTime");
    }
    return DateTimeOffset.CompareTo(((ServerTime)obj).DateTimeOffset);
  }

  public int CompareTo(ServerTime time)
  {
    return DateTimeOffset.CompareTo(time.DateTimeOffset);
  }

  public override bool Equals(object obj)
  {
    if (obj is ServerTime) {
      return DateTimeOffset.Equals(((ServerTime)obj).DateTimeOffset);
    }
    return false;
  }

  public bool Equals(ServerTime time)
  {
    return DateTimeOffset.Equals(time.DateTimeOffset);
  }

  public override int GetHashCode()
  {
    return DateTimeOffset.GetHashCode();
  }

  public TimeSpan Subtract(ServerTime time)
  {
    return DateTimeOffset.Subtract(time.DateTimeOffset);
  }

  public ServerTime Subtract(TimeSpan timeSpan)
  {
    return new ServerTime(DateTimeOffset.Subtract(timeSpan));
  }

  public double ToUnixTimeSeconds()
  {
    return (DateTimeOffset - new DateTimeOffset(1970, 1, 1, 0, 0, 0, DateTimeOffset.Offset)).TotalSeconds;
  }

  public ServerTime ToLocalTime()
  {
    return new ServerTime(DateTimeOffset.ToLocalTime());
  }

  public long ToFileTime(TimeSpan timeSpan)
  {
    return DateTimeOffset.ToFileTime();
  }

  public ServerTime ToOffset(TimeSpan timeSpan)
  {
    return new ServerTime(DateTimeOffset.ToOffset(timeSpan));
  }

  public override string ToString()
  {
    return _dateTimeOffset.ToString();
  }

  public string ToString(string format)
  {
    return _dateTimeOffset.ToString(format);
  }

  public ServerTime ToUniversalTime()
  {
    return new ServerTime(DateTimeOffset.ToUniversalTime());
  }
}

public class ServerTimeConverter : TypeConverter
{
  public ServerTimeConverter()
  {
  }

  public override Boolean CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
  {
    return sourceType == typeof(String);
  }

  public override Object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
  {
    if (value is String)
    {
      String stringValue = (String)value;
      return ServerTime.Parse(stringValue);
    }
    else return base.ConvertFrom(context, culture, value);
  }
}