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 RFC-3339 date-time format is used in a number of specifications such as the Atom Syndication Format.

score 64 · Answer 1 · edited Oct 22 '14 at 14:50

64

You don't need to write your own conversion code. Just use

XmlConvert.ToDateTime(string s, XmlDateTimeSerializationMode dateTimeOption)

to parse a RFC-3339 string, and

XmlConvert.ToString(DateTime value, XmlDateTimeSerializationMode dateTimeOption)

to convert a (UTC) datetime to a string.

Ref.
http://msdn.microsoft.com/en-us/library/ms162342(v=vs.110).aspx
http://msdn.microsoft.com/en-us/library/ms162344(v=vs.110).aspx

edited Oct 22 '14 at 14:50

dstj

4,800
2
39
61

answered Sep 18 '08 at 09:18

Matt Howells

40,310
20
83
102

6

Just to add that this library works fine parsing and converting dates from google calendar events to/from .NET Datetime – Yiannis Mpourkelis Dec 03 '14 at 23:35

score 22 · Accepted Answer · answered Aug 19 '08 at 21:42

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
{
    /// <summary>
    /// Provides methods for converting <see cref="DateTime"/> structures to and from the equivalent RFC 3339 string representation.
    /// </summary>
    public static class Rfc3339DateTime
    {
        //============================================================
        //  Private members
        //============================================================
        #region Private Members
        /// <summary>
        /// Private member to hold array of formats that RFC 3339 date-time representations conform to.
        /// </summary>
        private static string[] formats = new string[0];
        /// <summary>
        /// Private member to hold the DateTime format string for representing a DateTime in the RFC 3339 format.
        /// </summary>
        private const string format = "yyyy-MM-dd'T'HH:mm:ss.fffK";
        #endregion

        //============================================================
        //  Public Properties
        //============================================================
        #region Rfc3339DateTimeFormat
        /// <summary>
        /// Gets the custom format specifier that may be used to represent a <see cref="DateTime"/> in the RFC 3339 format.
        /// </summary>
        /// <value>A <i>DateTime format string</i> that may be used to represent a <see cref="DateTime"/> in the RFC 3339 format.</value>
        /// <remarks>
        /// <para>
        /// This method returns a string representation of a <see cref="DateTime"/> 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 <see cref="Rfc3339DateTimeFormat"/> is a valid 
        /// date-time format string for use in the <see cref="DateTime.ToString(String, IFormatProvider)"/> method.
        /// </para>
        /// </remarks>
        public static string Rfc3339DateTimeFormat
        {
            get
            {
                return format;
            }
        }
        #endregion

        #region Rfc3339DateTimePatterns
        /// <summary>
        /// Gets an array of the expected formats for RFC 3339 date-time string representations.
        /// </summary>
        /// <value>
        /// An array of the expected formats for RFC 3339 date-time string representations 
        /// that may used in the <see cref="DateTime.TryParseExact(String, string[], IFormatProvider, DateTimeStyles, out DateTime)"/> method.
        /// </value>
        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)
        /// <summary>
        /// Converts the specified string representation of a date and time to its <see cref="DateTime"/> equivalent.
        /// </summary>
        /// <param name="s">A string containing a date and time to convert.</param>
        /// <returns>A <see cref="DateTime"/> equivalent to the date and time contained in <paramref name="s"/>.</returns>
        /// <remarks>
        /// The string <paramref name="s"/> is parsed using formatting information in the <see cref="DateTimeFormatInfo.InvariantInfo"/> object.
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="s"/> is a <b>null</b> reference (Nothing in Visual Basic).</exception>
        /// <exception cref="FormatException"><paramref name="s"/> does not contain a valid RFC 3339 string representation of a date and time.</exception>
        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)
        /// <summary>
        /// Converts the value of the specified <see cref="DateTime"/> object to its equivalent string representation.
        /// </summary>
        /// <param name="utcDateTime">The Coordinated Universal Time (UTC) <see cref="DateTime"/> to convert.</param>
        /// <returns>A RFC 3339 string representation of the value of the <paramref name="utcDateTime"/>.</returns>
        /// <remarks>
        /// <para>
        /// This method returns a string representation of the <paramref name="utcDateTime"/> 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.
        /// </para>
        /// <para>
        /// 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.
        /// </para>
        /// </remarks>
        /// <exception cref="ArgumentException">The specified <paramref name="utcDateTime"/> object does not represent a <see cref="DateTimeKind.Utc">Coordinated Universal Time (UTC)</see> value.</exception>
        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)
        /// <summary>
        /// Converts the specified string representation of a date and time to its <see cref="DateTime"/> equivalent.
        /// </summary>
        /// <param name="s">A string containing a date and time to convert.</param>
        /// <param name="result">
        /// When this method returns, contains the <see cref="DateTime"/> value equivalent to the date and time 
        /// contained in <paramref name="s"/>, if the conversion succeeded, 
        /// or <see cref="DateTime.MinValue">MinValue</see> if the conversion failed. 
        /// The conversion fails if the s parameter is a <b>null</b> reference (Nothing in Visual Basic), 
        /// or does not contain a valid string representation of a date and time. 
        /// This parameter is passed uninitialized.
        /// </param>
        /// <returns><b>true</b> if the <paramref name="s"/> parameter was converted successfully; otherwise, <b>false</b>.</returns>
        /// <remarks>
        /// The string <paramref name="s"/> is parsed using formatting information in the <see cref="DateTimeFormatInfo.InvariantInfo"/> object.
        /// </remarks>
        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
    }
}

Why bother to write this code for something that is already in the BCL? — Matt Howells, Apr 01 '10 at 14:50
Have to agree with Matt here. RFC3339 isn't catered for by one of the DateTime.ToString standard formats - which is surprising - but XmlConvert does the job. E.g. I use XmlConvert.ToString(value, XmlDateTimeSerializationMode.Utc) — Bellarmine Head, Mar 05 '12 at 17:23
Hey @AndrewWebb, what if the data is formatted like this `2015-05-04T10:08:15+00:00` this. I heard that this is also considered RFC3339 but `RFC3339` won't recognize it as valid DateTime with none of the `XmlDateTimeSerializationMode` — Stoyan Dimov, May 04 '15 at 11:50
@StoyanDimov: `var d = System.Xml.XmlConvert.ToDateTime("2015-05-04T10:08:15+00:00", System.Xml.XmlDateTimeSerializationMode.Utc);` works for me. — Bellarmine Head, May 05 '15 at 12:51
Thanks for this, if you're on .NET Core XmlConvert is not available. — wonea, Oct 21 '16 at 09:41

score 2 · Answer 3 · answered Oct 18 '22 at 11:19

2

This worked for me in .NET 6:

public static class DateTimeExtensions
{
     public static string ToRFC3339(this DateTime date)
     {
         return date.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.fffK");
     }
}

answered Oct 18 '22 at 11:19

Pedro Coelho

1,411
3
18
31

score 0 · Answer 4 · answered Nov 12 '21 at 10:26

0

System.Text.Json does that as well:

JsonSerializer.Serialize(DateTime.Now)

answered Nov 12 '21 at 10:26

Andrey Stukalin

5,328
2
31
50

score -1 · Answer 5 · answered Jan 27 '20 at 14:27

-1

For completeness sake, Newtonsoft.Json will happily do it as well:

JsonConvert.SerializeObject(DateTime.Now);

(Unlike XmlConvert will have have escaped double-quotes on each end.)

answered Jan 27 '20 at 14:27

rothschild86

1,433
16
22

score -1 · Answer 6 · edited Nov 13 '21 at 11:19

-1

<input asp-for="StartDate" class="form-control" value="@DateTime.Now.ToString("yyyy-MM-ddThh:mm:ss")" />

edited Nov 13 '21 at 11:19

Mark Rotteveel

100,966
191
140
197

answered Sep 03 '21 at 15:57

Felipe Maricato Moura

57
1
1
8

1

Please add further details to expand on your answer, such as working code or documentation citations. – Community Sep 03 '21 at 19:53

score -3 · Answer 7 · edited Dec 06 '22 at 13:12

-3

In .NET (assuming UTC):

 datetime.ToString("yyyy-MM-dd'T'HH:mm:ssZ")

DateTime.Parse() can be used to convert back into a DateTime structure.

edited Dec 06 '22 at 13:12

Jim Aho

9,932
15
56
87

answered Aug 19 '08 at 21:44

Mark Cidade

98,437
31
224
236

1

Don't think "YYYY-MM-DD'T'HH:mm:ss" can be right; it has no offset from UTC, nor 'Z' (= zero offset from UTC). – Bellarmine Head Mar 02 '12 at 14:05
3

This didn't work for me. I had to use `datetime.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ssZ")` – Tomáš Linhart Jun 08 '16 at 21:29
4

It only works when the DateTime is in the UTC time zone (_universal time_). – Mark Cidade Jun 09 '16 at 00:20
1

has to be yyyy, and dd, not capitals – Aris Feb 19 '21 at 19:32

score -6 · Answer 8 · edited Apr 12 '17 at 00:32

-6

A simple equation will able to obtain the result you are after:

rfcFormat = DateDiff("s", "1/1/1970", Now())

edited Apr 12 '17 at 00:32

Unheilig

16,196
193
68
98

answered Apr 11 '17 at 23:56

user1560963

25
7

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

8 Answers8

Linked