Nsryjdtyk

Note to readers: Several commenters have pointed out some problems in this answer (related particularly to the first suggestion). Refer to the comments section for more information.

DateTime.UtcNow.ToString("yyyy-MM-ddTHH\:mm\:ss.fffffffzzz");

This gives you a date similar to 2008-09-22T13:57:31.2311892-04:00.

Another way is:

DateTime.UtcNow.ToString("o");

which gives you 2008-09-22T14:01:54.9571247Z

To get the specified format, you can use:

DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")

DateTime Formatting Options

DateTime.UtcNow.ToString("s", System.Globalization.CultureInfo.InvariantCulture) should give you what you are looking for as the "s" format specifier is described as a sortable date/time pattern; conforms to ISO 8601.

DateTime.UtcNow.ToString("s")

Returns something like 2008-04-10T06:30:00

UtcNow obviously returns a UTC time so there is no harm in:

string.Concat(DateTime.UtcNow.ToString("s"), "Z")

Use:

private void TimeFormats()

{

    DateTime localTime = DateTime.Now;

    DateTime utcTime = DateTime.UtcNow;

    DateTimeOffset localTimeAndOffset = new DateTimeOffset(localTime, TimeZoneInfo.Local.GetUtcOffset(localTime));



    //UTC

    string strUtcTime_o = utcTime.ToString("o");

    string strUtcTime_s = utcTime.ToString("s");

    string strUtcTime_custom = utcTime.ToString("yyyy-MM-ddTHH:mm:ssK");



    //Local

    string strLocalTimeAndOffset_o = localTimeAndOffset.ToString("o");

    string strLocalTimeAndOffset_s = localTimeAndOffset.ToString("s");

    string strLocalTimeAndOffset_custom = utcTime.ToString("yyyy-MM-ddTHH:mm:ssK");



    //Output

    Response.Write("<br/>UTC<br/>");

    Response.Write("strUtcTime_o: " + strUtcTime_o + "<br/>");

    Response.Write("strUtcTime_s: " + strUtcTime_s + "<br/>");

    Response.Write("strUtcTime_custom: " + strUtcTime_custom + "<br/>");



    Response.Write("<br/>Local Time<br/>");

    Response.Write("strLocalTimeAndOffset_o: " + strLocalTimeAndOffset_o + "<br/>");

    Response.Write("strLocalTimeAndOffset_s: " + strLocalTimeAndOffset_s + "<br/>");

    Response.Write("strLocalTimeAndOffset_custom: " + strLocalTimeAndOffset_custom + "<br/>");



}

OUTPUT

UTC

    strUtcTime_o: 2012-09-17T22:02:51.4021600Z

    strUtcTime_s: 2012-09-17T22:02:51

    strUtcTime_custom: 2012-09-17T22:02:51Z



Local Time

    strLocalTimeAndOffset_o: 2012-09-17T15:02:51.4021600-07:00

    strLocalTimeAndOffset_s: 2012-09-17T15:02:51

    strLocalTimeAndOffset_custom: 2012-09-17T22:02:51Z

Sources:

• Standard Date and Time Format Strings (MSDN)




• Custom Date and Time Format Strings (MSDN)

System.DateTime.UtcNow.ToString("o")

=>

val it : string = "2013-10-13T13:03:50.2950037Z"

If you must use DateTime to ISO 8601, then ToString("o") should yield what you are looking for. For example,

2015-07-06T12:08:27

However, DateTime + TimeZone may present other problems as described in the blog post DateTime and DateTimeOffset in .NET: Good practices and common pitfalls:

DateTime has countless traps in it that are designed to give your code bugs:

1.- DateTime values with DateTimeKind.Unspecified are bad news.

2.- DateTime doesn't care about UTC/Local when doing comparisons.

3.- DateTime values are not aware of standard format strings.

4.- Parsing a string that has a UTC marker with DateTime does not guarantee a UTC time.

You can get the "Z" (ISO 8601 UTC) with the next code:

Dim tmpDate As DateTime = New DateTime(Now.Ticks, DateTimeKind.Utc)

Dim res as String = tmpDate.toString("o") '2009-06-15T13:45:30.0000000Z

Here is why:

The ISO 8601 have some different formats:

DateTimeKind.Local

2009-06-15T13:45:30.0000000-07:00

DateTimeKind.Utc

2009-06-15T13:45:30.0000000Z

DateTimeKind.Unspecified

2009-06-15T13:45:30.0000000

.NET provides us with an enum with those options:

'2009-06-15T13:45:30.0000000-07:00

Dim strTmp1 As String = New DateTime(Now.Ticks, DateTimeKind.Local).ToString("o")



'2009-06-15T13:45:30.0000000Z

Dim strTmp2 As String = New DateTime(Now.Ticks, DateTimeKind.Utc).ToString("o")



'2009-06-15T13:45:30.0000000

Dim strTmp3 As String = New DateTime(Now.Ticks, DateTimeKind.Unspecified).ToString("o")

Note: If you apply the Visual Studio 2008 "watch utility" to the toString("o") part you may get different results, I don't know if it's a bug, but in this case you have better results using a String variable if you're debugging.

Source: Standard Date and Time Format Strings (MSDN)

I would just use XmlConvert:

XmlConvert.ToString(DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind);

It will automatically preserve the time zone.

Most of these answers have milliseconds / microseconds which clearly isn't supported by ISO 8601. The correct answer would be:

System.DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ssK");

// or

System.DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK");

References:

• ISO 8601 specification


• 
  "K" Specifier

The "s" standard format specifier represents a custom date and time format string that is defined by the DateTimeFormatInfo.SortableDateTimePattern property. The pattern reflects a defined standard (ISO 8601), and the property is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied. The custom format string is "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

When this standard format specifier is used, the formatting or parsing operation always uses the invariant culture.

– from MSDN

To convert DateTime.UtcNow to a string representation of yyyy-MM-ddTHH:mm:ssZ, you can use the ToString() method of the DateTime structure with a custom formatting string. When using custom format strings with a DateTime, it is important to remember that you need to escape your seperators using single quotes.

The following will return the string represention you wanted:

DateTime.UtcNow.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'", DateTimeFormatInfo.InvariantInfo)

DateTime.Now.ToString("yyyy-MM-dd'T'HH:mm:ss zzz");



DateTime.Now.ToString("O");

NOTE: Depending on the conversion you are doing on your end, you will be using the first line (most like it) or the second one.

Make sure to applied format only at local time, since "zzz" is the time zone information for UTC conversion.

It is interesting that custom format "yyyy-MM-ddTHH:mm:ssK" (without ms) is the quickest format method.

Also it is interesting that "S" format is slow on Classic and fast on Core...

Of course numbers are very close, between some rows difference is insignificant (tests with suffix _Verify are the same as those that are without that suffix, demonstrates results repeatability)

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393

Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4

Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC

  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0

  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0

  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT





               Method |  Job | Runtime |       Mean |     Error |    StdDev |     Median |        Min |        Max | Rank |  Gen 0 | Allocated |

--------------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:|

           CustomDev1 |  Clr |     Clr | 1,089.0 ns | 22.179 ns | 20.746 ns | 1,079.9 ns | 1,068.9 ns | 1,133.2 ns |    8 | 0.1086 |     424 B |

           CustomDev2 |  Clr |     Clr | 1,032.3 ns | 19.897 ns | 21.289 ns | 1,024.7 ns | 1,000.3 ns | 1,072.0 ns |    7 | 0.1165 |     424 B |

     CustomDev2WithMS |  Clr |     Clr | 1,168.2 ns | 16.543 ns | 15.474 ns | 1,168.5 ns | 1,149.3 ns | 1,189.2 ns |   10 | 0.1625 |     592 B |

              FormatO |  Clr |     Clr | 1,563.7 ns | 31.244 ns | 54.721 ns | 1,532.5 ns | 1,497.8 ns | 1,703.5 ns |   14 | 0.2897 |     976 B |

              FormatS |  Clr |     Clr | 1,243.5 ns | 24.615 ns | 31.130 ns | 1,229.3 ns | 1,200.6 ns | 1,324.2 ns |   13 | 0.2865 |     984 B |

       FormatS_Verify |  Clr |     Clr | 1,217.6 ns | 11.486 ns | 10.744 ns | 1,216.2 ns | 1,205.5 ns | 1,244.3 ns |   12 | 0.2885 |     984 B |

        CustomFormatK |  Clr |     Clr |   912.2 ns | 17.915 ns | 18.398 ns |   916.6 ns |   878.3 ns |   934.1 ns |    4 | 0.0629 |     240 B |

 CustomFormatK_Verify |  Clr |     Clr |   894.0 ns |  3.877 ns |  3.626 ns |   893.8 ns |   885.1 ns |   900.0 ns |    3 | 0.0636 |     240 B |

           CustomDev1 | Core |    Core |   989.1 ns | 12.550 ns | 11.739 ns |   983.8 ns |   976.8 ns | 1,015.5 ns |    6 | 0.1101 |     423 B |

           CustomDev2 | Core |    Core |   964.3 ns | 18.826 ns | 23.809 ns |   954.1 ns |   935.5 ns | 1,015.6 ns |    5 | 0.1267 |     423 B |

     CustomDev2WithMS | Core |    Core | 1,136.0 ns | 21.914 ns | 27.714 ns | 1,138.1 ns | 1,099.9 ns | 1,200.2 ns |    9 | 0.1752 |     590 B |

              FormatO | Core |    Core | 1,201.5 ns | 16.262 ns | 15.211 ns | 1,202.3 ns | 1,178.2 ns | 1,225.5 ns |   11 | 0.0656 |     271 B |

              FormatS | Core |    Core |   993.5 ns | 19.272 ns | 24.372 ns |   999.4 ns |   954.2 ns | 1,029.5 ns |    6 | 0.0633 |     279 B |

       FormatS_Verify | Core |    Core | 1,003.1 ns | 17.577 ns | 16.442 ns | 1,009.2 ns |   976.1 ns | 1,024.3 ns |    6 | 0.0674 |     279 B |

        CustomFormatK | Core |    Core |   878.2 ns | 17.017 ns | 20.898 ns |   877.7 ns |   851.4 ns |   928.1 ns |    2 | 0.0555 |     215 B |

 CustomFormatK_Verify | Core |    Core |   863.6 ns |  3.968 ns |  3.712 ns |   863.0 ns |   858.6 ns |   870.8 ns |    1 | 0.0550 |     215 B |

Code:

    public class BenchmarkDateTimeFormat

    {

        public static DateTime dateTime = DateTime.Now;



        [Benchmark]

        public string CustomDev1()

        {

            var d = dateTime.ToUniversalTime();

            var sb = new StringBuilder(20);



            sb.Append(d.Year).Append("-");

            if (d.Month <= 9)

                sb.Append("0");

            sb.Append(d.Month).Append("-");

            if (d.Day <= 9)

                sb.Append("0");

            sb.Append(d.Day).Append("T");

            if (d.Hour <= 9)

                sb.Append("0");

            sb.Append(d.Hour).Append(":");

            if (d.Minute <= 9)

                sb.Append("0");

            sb.Append(d.Minute).Append(":");

            if (d.Second <= 9)

                sb.Append("0");

            sb.Append(d.Second).Append("Z");

            var text = sb.ToString();

            return text;

        }



        [Benchmark]

        public string CustomDev2()

        {

            var u = dateTime.ToUniversalTime();

            var sb = new StringBuilder(20);

            var y = u.Year;

            var d = u.Day;

            var M = u.Month;

            var h = u.Hour;

            var m = u.Minute;

            var s = u.Second;

            sb.Append(y).Append("-");

            if (M <= 9)

                sb.Append("0");

            sb.Append(M).Append("-");

            if (d <= 9)

                sb.Append("0");

            sb.Append(d).Append("T");

            if (h <= 9)

                sb.Append("0");

            sb.Append(h).Append(":");

            if (m <= 9)

                sb.Append("0");

            sb.Append(m).Append(":");

            if (s <= 9)

                sb.Append("0");

            sb.Append(s).Append("Z");

            var text = sb.ToString();

            return text;

        }



        [Benchmark]

        public string CustomDev2WithMS()

        {

            var u  = dateTime.ToUniversalTime();

            var sb = new StringBuilder(23);

            var y  = u.Year;

            var d  = u.Day;

            var M  = u.Month;

            var h  = u.Hour;

            var m  = u.Minute;

            var s  = u.Second;

            var ms = u.Millisecond;

            sb.Append(y).Append("-");

            if (M <= 9)

                sb.Append("0");

            sb.Append(M).Append("-");

            if (d <= 9)

                sb.Append("0");

            sb.Append(d).Append("T");

            if (h <= 9)

                sb.Append("0");

            sb.Append(h).Append(":");

            if (m <= 9)

                sb.Append("0");

            sb.Append(m).Append(":");

            if (s <= 9)

                sb.Append("0");

            sb.Append(s).Append(".");

            sb.Append(ms).Append("Z");

            var text = sb.ToString();

            return text;

        }

        [Benchmark]

        public string FormatO()

        {

            var text = dateTime.ToUniversalTime().ToString("o");

            return text;

        }

        [Benchmark]

        public string FormatS()

        {

            var text = string.Concat(dateTime.ToUniversalTime().ToString("s"),"Z");

            return text;

        }



        [Benchmark]

        public string FormatS_Verify()

        {

            var text = string.Concat(dateTime.ToUniversalTime().ToString("s"), "Z");

            return text;

        }



        [Benchmark]

        public string CustomFormatK()

        {

            var text = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK");

            return text;

        }



        [Benchmark]

        public string CustomFormatK_Verify()

        {

            var text = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK");

            return text;

        }

    }

https://github.com/dotnet/BenchmarkDotNet was used

If you're developing under SharePoint 2010 or higher you can use

using Microsoft.SharePoint;

using Microsoft.SharePoint.Utilities;

...

string strISODate = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now)

To format like 2018-06-22T13:04:16 which can be passed in the URI of an API use:

public static string FormatDateTime(DateTime dateTime)

{

    return dateTime.ToString("s", System.Globalization.CultureInfo.InvariantCulture);

}