How do I parse and convert a DateTime to the RFC 3339 date-time format?

Question

How do I convert a DateTime structure to its equivalent RFC 3339 formatted string representation and/or parse this string representation back to a DateTime structure? The RF

Answer 1

This is an implementation in C# of how to parse and convert a DateTime to and from its RFC-3339 representation. The only restriction it has is that the DateTime is in Coordinated Universal Time (UTC).

using System;
using System.Globalization;

namespace DateTimeConsoleApplication
{
    /// 

    /// Provides methods for converting  structures to and from the equivalent RFC 3339 string representation.
    /// 
    public static class Rfc3339DateTime
    {
        //============================================================
        //  Private members
        //============================================================
        #region Private Members
        /// 

        /// Private member to hold array of formats that RFC 3339 date-time representations conform to.
        /// 
        private static string[] formats = new string[0];
        /// 

        /// Private member to hold the DateTime format string for representing a DateTime in the RFC 3339 format.
        /// 
        private const string format = "yyyy-MM-dd'T'HH:mm:ss.fffK";
        #endregion

        //============================================================
        //  Public Properties
        //============================================================
        #region Rfc3339DateTimeFormat
        /// 

        /// Gets the custom format specifier that may be used to represent a  in the RFC 3339 format.
        /// 
        /// A DateTime format string that may be used to represent a  in the RFC 3339 format.
        /// 
        /// 
        /// This method returns a string representation of a  that 
        /// is precise to the three most significant digits of the seconds fraction; that is, it represents 
        /// the milliseconds in a date and time value. The  is a valid 
        /// date-time format string for use in the  method.
        /// 
        /// 
        public static string Rfc3339DateTimeFormat
        {
            get
            {
                return format;
            }
        }
        #endregion

        #region Rfc3339DateTimePatterns
        /// 

        /// Gets an array of the expected formats for RFC 3339 date-time string representations.
        /// 
        /// 
        /// An array of the expected formats for RFC 3339 date-time string representations 
        /// that may used in the  method.
        /// 
        public static string[] Rfc3339DateTimePatterns
        {
            get
            {
                if (formats.Length > 0)
                {
                    return formats;
                }
                else
                {
                    formats = new string[11];

                    // Rfc3339DateTimePatterns
                    formats[0] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK";
                    formats[1] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'ffffffK";
                    formats[2] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffK";
                    formats[3] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'ffffK";
                    formats[4] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffK";
                    formats[5] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'ffK";
                    formats[6] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fK";
                    formats[7] = "yyyy'-'MM'-'dd'T'HH':'mm':'ssK";

                    // Fall back patterns
                    formats[8] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK"; // RoundtripDateTimePattern
                    formats[9] = DateTimeFormatInfo.InvariantInfo.UniversalSortableDateTimePattern;
                    formats[10] = DateTimeFormatInfo.InvariantInfo.SortableDateTimePattern;

                    return formats;
                }
            }
        }
        #endregion

        //============================================================
        //  Public Methods
        //============================================================
        #region Parse(string s)
        /// 

        /// Converts the specified string representation of a date and time to its  equivalent.
        /// 
        /// A string containing a date and time to convert.
        /// A  equivalent to the date and time contained in .
        /// 
        /// The string  is parsed using formatting information in the  object.
        /// 
        ///  is a null reference (Nothing in Visual Basic).
        ///  does not contain a valid RFC 3339 string representation of a date and time.
        public static DateTime Parse(string s)
        {
            //------------------------------------------------------------
            //  Validate parameter
            //------------------------------------------------------------
            if(s == null)
            {
                throw new ArgumentNullException("s");
            }

            DateTime result;
            if (Rfc3339DateTime.TryParse(s, out result))
            {
                return result;
            }
            else
            {
                throw new FormatException(String.Format(null, "{0} is not a valid RFC 3339 string representation of a date and time.", s));
            }
        }
        #endregion

        #region ToString(DateTime utcDateTime)
        /// 

        /// Converts the value of the specified  object to its equivalent string representation.
        /// 
        /// The Coordinated Universal Time (UTC)  to convert.
        /// A RFC 3339 string representation of the value of the .
        /// 
        /// 
        /// This method returns a string representation of the  that 
        /// is precise to the three most significant digits of the seconds fraction; that is, it represents 
        /// the milliseconds in a date and time value.
        /// 
        /// 
        /// While it is possible to display higher precision fractions of a second component of a time value, 
        /// that value may not be meaningful. The precision of date and time values depends on the resolution 
        /// of the system clock. On Windows NT 3.5 and later, and Windows Vista operating systems, the clock's 
        /// resolution is approximately 10-15 milliseconds.
        /// 
        /// 
        /// The specified  object does not represent a Coordinated Universal Time (UTC) value.
        public static string ToString(DateTime utcDateTime)
        {
            if (utcDateTime.Kind != DateTimeKind.Utc)
            {
                throw new ArgumentException("utcDateTime");
            }

            return utcDateTime.ToString(Rfc3339DateTime.Rfc3339DateTimeFormat, DateTimeFormatInfo.InvariantInfo);
        }
        #endregion

        #region TryParse(string s, out DateTime result)
        /// 

        /// Converts the specified string representation of a date and time to its  equivalent.
        /// 
        /// A string containing a date and time to convert.
        /// 
        /// When this method returns, contains the  value equivalent to the date and time 
        /// contained in , if the conversion succeeded, 
        /// or MinValue if the conversion failed. 
        /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), 
        /// or does not contain a valid string representation of a date and time. 
        /// This parameter is passed uninitialized.
        /// 
        /// true if the  parameter was converted successfully; otherwise, false.
        /// 
        /// The string  is parsed using formatting information in the  object.
        /// 
        public static bool TryParse(string s, out DateTime result)
        {
            //------------------------------------------------------------
            //  Attempt to convert string representation
            //------------------------------------------------------------
            bool wasConverted   = false;
            result              = DateTime.MinValue;

            if (!String.IsNullOrEmpty(s))
            {
                DateTime parseResult;
                if (DateTime.TryParseExact(s, Rfc3339DateTime.Rfc3339DateTimePatterns, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AdjustToUniversal, out parseResult))
                {
                    result          = DateTime.SpecifyKind(parseResult, DateTimeKind.Utc);
                    wasConverted    = true;
                }
            }

            return wasConverted;
        }
        #endregion
    }
}