DateTime nesnesi verildiğinde, dize biçiminde ISO 8601 tarihini nasıl alabilirim?


790

Verilen:

DateTime.UtcNow

ISO 8601 uyumlu bir biçimde aynı değeri temsil eden bir dize nasıl alabilirim ?

ISO 8601'in bir dizi benzer formatı tanımladığını unutmayın. Aradığım özel biçim:

yyyy-MM-ddTHH:mm:ssZ

Yanıtlar:


780

Okuyucular için not: Birkaç yorumcu bu cevapta bazı problemlere dikkat çekti (özellikle ilk öneriyle ilgili). Daha fazla bilgi için yorumlar bölümüne bakın.

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

Bu, 2008-09-22T13: 57: 31.2311892-04: 00'a benzer bir tarih verir .

Başka bir yol:

DateTime.UtcNow.ToString("o");

size 2008-09-22T14: 01: 54.9571247Z verir

Belirtilen biçimi almak için şunları kullanabilirsiniz:

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

DateTime Biçimlendirme Seçenekleri


20
Bu günlerde, bunu yapmak (çok anlamlı olmayan bir ofset ile UTC saati oluşturmaya çalışmak) bir istisna atar. Bu yüzden, diğerleriyle aynı fikirdeyim, değişmez kültür ile "s" biçiminin muhtemelen daha doğru olduğunu. FYI, formatexception'ın mesajı şu şekildedir: "Bir UTC DateTime, yalnızca yerel saatler için doğru olan bir formattaki metne dönüştürülüyor. Bu, yerel bir saat dilimi ofseti içerecek olan 'z' biçim belirleyicisini kullanarak DateTime.ToString çağrıldığında gerçekleşebilir. çıktı. "
Tom Lianza

9
Avustralya'da yaşıyorum ve benim ToString("yyyy-MM-ddTHH:mm:ssK")için bunun için kullanmak zorunda kaldım (kullandığım jquery timeago eklentisi ile).
GONeale

6
Saat dilimi ofsetini eklemek istiyorsanız, şunu yapın: dt.ToString("s") + dt.ToString("zzz")// 2013-12-05T07: 19: 04-08: 00
alekop

4
Eğik çizgiler (\ :), dizeyle ilgili sorunlara neden olur ... bunun yerine @ karakterini dizgi değişmezi kullanmak için kullanın.
Gigi

6
@core: bu, bağlantılı özel Biçimlerden farklı olan standart Biçimlerden biridir: msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx
Wayne

361

DateTime.UtcNow.ToString("s", System.Globalization.CultureInfo.InvariantCulture)"s" biçim belirteci sıralanabilir bir tarih / saat modeli olarak tanımlandığından, aradığınızı vermeniz gerekir; ISO 8601'e uygundur.


34
Bunun doğru cevap olduğuna inanıyorum. Microsoft, ISO 8601'i zaten uyguladıysa, yyyy-MM-etc'yi açıkça tanımlamanın bir anlamı yoktur. Iain'nin yanıtı da doğruydu, ancak her zaman InvariantCulture'u (veya başka bir CultureInfo) birden çok nedenden dolayı belirtmelisiniz (örneğin, .NET'in varsayalım). Ayrıca şunları da kullanabilirsiniz: DateTime.UtcNow.ToString(CultureInfo.InvariantCulture.DateTimeFormat.SortableDateTimePattern); Ancak, bunların tümü saat dilimini vb. Hariç tuttuğundan, açık biçimlendiriciyi kullanmaktan başka seçeneğiniz olmayabilir, yani"yyyy-MM-ddTHH:mm:ss.fffZ"
Jon Davis

20
Uygun olsa da, aşağıdaki gibi zaman dilimini terk eder Z: DateTime.UtcNow.ToString(c, CultureInfo.InvariantCulture)) => 2012-06-26T11:55:36ve bilgisayarlar saniyede adil sayıda keneler yaptığı için çok güzel bir milisaniye çözünürlük yoktur.
Henrik

9
İle oAlacağınız 2012-06-26T11:55:36.1007668Zanlam 36.1007668saniye, bu nedenle aşağı çözünürlük olsun 1/10^7saniyenin. ISO8601: 2004'tenIf a decimal fraction is included, lower order time elements (if any) shall be omitted and the decimal fraction shall be divided from the integer part by the decimal sign [...] the comma (,) or full stop (.)
Henrik


2
@binki - şimdi çok kafam karıştı. SortableDateTimePattern için daha önce bağladığım belgelere göre , kültüre özgü olması gerektiğini söylüyor. ANCAK, kendi örnekleriyle çelişiyor gibi görünüyor (hepsi aynı göründüğü için); deneyin DateTime.Now.ToString("s", new CultureInfo(myCulture)).
drzaus

87
DateTime.UtcNow.ToString("s")

2008-04-10T06: 30: 00 gibi bir şey döndürür

UtcNowAçıkçası bir UTC saati döndürdüğü için hiçbir zarar vermez:

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

11
Sadece ilgisiz: Neden '+' yerine string.Concat ()?
Daniel Fortunov

2
Alışkanlık, fark var mı?
Iain

84
@KoenZomers: Bunun doğru olduğunu düşünmüyorum. Bence a + baynı ara kod derler string.Concat(a, b)(tabii ki a ve b dizeleri olduğunu varsayarak) böylece performans veya bellek tüketiminde bir fark yoktur.
Mark Byers

78
Evet, Mark doğru. Koen, haklı olsanız bile, saçma bir erken mikro-optimizasyon tuzağına düştünüz.
Noldorin

7
@ greg84: Tamamen haklı değilsin. Microsoft mimar Rico Mariani'nin bu yazısına bakın : blogs.msdn.com/b/ricom/archive/2003/12/15/43628.aspx - a + b'nin concat için derlediğini + doğru kullanımı hakkında daha fazla bilgi olduğunu söylüyor StringBuilder.
mrówa

37

kullanın:

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/>");

}

ÇIKTI

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

Kaynaklar:


2
yerel geleneklere kopyalama kurbanı gibi görünüyor ;-) string strLocalTimeAndOffset_custom = localTimeAndOffset.ToString("yyyy-MM-ddTHH:mm:ssK");sonuç:strLocalTimeAndOffset_custom: 2012-09-17T22:02:51-07:00
Holly

obir ISO-8601 biçimidir.
Yousha Aleayoub

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

=>

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

Kesinlikle bu herhangi bir saat diliminde kesin bir tarih / saat olduğundan emin olmanın tek yoludur
Matt Wilko

23

"Z" ( ISO 8601 UTC ) kodunu aşağıdaki kodla alabilirsiniz:

Dim tmpDate As DateTime = New DateTime(Now.Ticks, DateTimeKind.Utc)
Dim res as String = tmpDate.toString("o") '2009-06-15T13:45:30.0000000Z


İşte nedeni:

ISO 8601'in bazı farklı formatları vardır:

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 bize bu seçenekleri içeren bir numaralandırma sağlar:

'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")

Not : toString ("o") bölümüne Visual Studio 2008 "watch yardımcı programı" uygularsanız farklı sonuçlar alabilirsiniz, bunun bir hata olup olmadığını bilmiyorum, ancak bu durumda bir String değişkeni kullanarak daha iyi sonuçlarınız var hata ayıklama yapıyorsanız.

Kaynak: Standart Tarih ve Saat Biçimi Dizeleri (MSDN)


20

DateTime'ı ISO 8601 olarak kullanmanız gerekiyorsa, ToString ("o") aradığınızı vermelidir. Örneğin,

2015-07-06T12:08:27

Ancak, DateTime + TimeZone .NET'teki DateTime ve DateTimeOffset blog yayınında açıklandığı gibi başka sorunlar sunabilir : İyi uygulamalar ve yaygın tuzaklar :

DateTime içinde kod hatalarınızı vermek için tasarlanmış sayısız tuzak vardır:

1.- DateTimeKind.Unspifiedified ile DateTime değerleri kötü haber.

2.- Karşılaştırma yaparken DateTime UTC / Yerel ile ilgilenmez.

3.- DateTime değerleri standart biçim dizelerinin farkında değildir.

4.- DateTime ile UTC işaretçisi olan bir dizenin ayrıştırılması UTC saatini garanti etmez.


2
ISO8601 stravada bir tane için kullanılır. Ancak, milisaniye vb.
Ekleyen

2
Benim için, "yyyy-AA-gg-THH: mm: ssZ" tam anlamıyla benim dize sonunda bir saat dilimi işareti yerine "Z" çıktı, ne istediğimi yapmadı. ToString ("o") aslında ihtiyacım olanı çok daha kolay ve kısa yaptı.
Blair Connolly

18

Kimsenin önermediğine şaşırdım:

System.DateTime.UtcNow.ToString("u").Replace(' ','T')
# Using PowerShell Core to demo

# Lowercase "u" format
[System.DateTime]::UtcNow.ToString("u")
> 2020-02-06 01:00:32Z

# Lowercase "u" format with replacement
[System.DateTime]::UtcNow.ToString("u").Replace(' ','T')
> 2020-02-06T01:00:32Z

UniversalSortableDateTimePattern (diğer bir olan ne istediğinizi size neredeyse tüm yol alır RFC 3339 gösterim).


Eklendi: Bunun nasıl çalıştığını karşılaştırmak için https://stackoverflow.com/a/43793679/653058 adresinde bulunan karşılaştırmaları kullanmaya karar verdim .

tl: dr; pahalı sonunda ama hala sadece biraz üzerinde yarım milisaniye benim crappy eski dizüstü :-)

Uygulama:

[Benchmark]
public string ReplaceU()
{
   var text = dateTime.ToUniversalTime().ToString("u").Replace(' ', 'T');
   return text;
}

Sonuçlar:

// * Summary *

BenchmarkDotNet=v0.11.5, OS=Windows 10.0.19002
Intel Xeon CPU E3-1245 v3 3.40GHz, 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.0.100
  [Host]     : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
  DefaultJob : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT


|               Method |     Mean |     Error |    StdDev |
|--------------------- |---------:|----------:|----------:|
|           CustomDev1 | 562.4 ns | 11.135 ns | 10.936 ns |
|           CustomDev2 | 525.3 ns |  3.322 ns |  3.107 ns |
|     CustomDev2WithMS | 609.9 ns |  9.427 ns |  8.356 ns |
|              FormatO | 356.6 ns |  6.008 ns |  5.620 ns |
|              FormatS | 589.3 ns |  7.012 ns |  6.216 ns |
|       FormatS_Verify | 599.8 ns | 12.054 ns | 11.275 ns |
|        CustomFormatK | 549.3 ns |  4.911 ns |  4.594 ns |
| CustomFormatK_Verify | 539.9 ns |  2.917 ns |  2.436 ns |
|             ReplaceU | 615.5 ns | 12.313 ns | 11.517 ns |

// * Hints *
Outliers
  BenchmarkDateTimeFormat.CustomDev2WithMS: Default     -> 1 outlier  was  removed (668.16 ns)
  BenchmarkDateTimeFormat.FormatS: Default              -> 1 outlier  was  removed (621.28 ns)
  BenchmarkDateTimeFormat.CustomFormatK: Default        -> 1 outlier  was  detected (542.55 ns)
  BenchmarkDateTimeFormat.CustomFormatK_Verify: Default -> 2 outliers were removed (557.07 ns, 560.95 ns)

// * Legends *
  Mean   : Arithmetic mean of all measurements
  Error  : Half of 99.9% confidence interval
  StdDev : Standard deviation of all measurements
  1 ns   : 1 Nanosecond (0.000000001 sec)

// ***** BenchmarkRunner: End *****

1
Kabul edilen "o" cevabı işe yarıyor, ancak sinir bozucu bir miktar hassasiyet (geez .ODX saniye) verirken, saniyeler içinde durduğundan bunu tercih ediyorum.
19'da

Ayrıca bu doktor "u" nun ISO 8601 olduğunu iddia ediyor, ama T yerine boşluk nedir? birlikte olsun microsoft
19:45 de jhocking

@jhocking en.wikipedia.org/wiki/ISO_8601#cite_note-30 ISO 8601, okuduysanız nispeten izin
vericidir

16

Ben sadece kullanmak istiyorum XmlConvert:

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

Saat dilimini otomatik olarak korur.


Devam ettim ve bir uzatma yöntemi ekledim. public static class DateTimeExtensions {public static string ToIsoFormat (this DateTime dateTime) {return XmlConvert.ToString (dateTime, XmlDateTimeSerializationMode.RoundtripKind); }}
muruge

14

Bu cevapların çoğunda ISO 8601 tarafından açıkça desteklenmeyen milisaniye / mikrosaniye vardır. Doğru cevap şöyle olacaktır:

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

Referanslar:


15
"Times" altında kendi Wikipedia bağlantınızı okuyun. ISO 8601'in hem milisaniyeyi hem de mikrosaniyeyi desteklediği anlamına gelen "Ondalık kesirler" den bahseder (ancak iletişim kuran taraflar kabul edilen ondalık basamak sayısını sınırlayabilir).
Søren Boisen

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

DateTime.Now.ToString("O");

NOT: Sonunda yaptığınız dönüşüme bağlı olarak, ilk satırı (en çok benzeyen) veya ikincisini kullanacaksınız.

"Zzz", UTC dönüşümü için saat dilimi bilgileri olduğundan, biçimi yalnızca yerel saatte uyguladığınızdan emin olun.

görüntü


#ChrisHynes o ilk kod satırı ile ilgili öneride sorduğu için emin değilim, ama eğer doğru ve bu durumda cevap "ReSharper"
PSM

9

"s"Standart biçim belirteci ile tanımlanır özel bir tarih ve saat biçim dizesi temsil DateTimeFormatInfo.SortableDateTimePattern özelliği. Desen tanımlı bir standardı ( ISO 8601 ) yansıtır ve özellik salt okunurdur. Bu nedenle, kullanılan kültürden veya sağlanan format sağlayıcıdan bağımsız olarak her zaman aynıdır. Özel biçim dizesi "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

Bu standart biçim belirteci kullanıldığında, biçimlendirme veya ayrıştırma işlemi her zaman değişmez kültürü kullanır.

- MSDN'den


1
Yani kullanmak uygun .ToString("s")mu?
AhmetB - Google

Öyle inanıyorum. - Gereksiniminiz orijinal soru ile eşleştiği sürece .. Ama aşağıdaki simon wilson tarafından uyarıya bir göz atın
Amal

9

DateTime.UtcNow öğesini yyyy-AA-ggTHH: mm: ssZ karakter dizisine dönüştürmek için , DateTime yapısının ToString () yöntemini özel bir biçimlendirme dizesiyle kullanabilirsiniz. DateTime ile özel biçim dizeleri kullanırken, ayırıcılardan tek tırnak kullanarak kaçmanız gerektiğini hatırlamanız önemlidir.

Aşağıdakiler istediğiniz dize temsilini döndürür:

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

9

"Yyyy-AA-ggTHH: mm: ssK" özel biçiminin (ms olmadan) en hızlı biçim yöntemi olması ilginçtir.

Ayrıca ilginç "S" biçimi Klasik yavaş ve Core hızlı ...

Tabii ki sayılar çok yakın, bazı satırlar arasındaki fark önemsiz (sonekle yapılan testler, bu soneksiz _Verifyolanlarla aynıdır, sonuçların tekrarlanabilirliğini gösterir)

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 |

Kod:

    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 kullanıldı



2

SharePoint 2010 veya daha yeni bir sürüm altında geliştiriyorsanız aşağıdakileri kullanabilirsiniz:

using Microsoft.SharePoint;
using Microsoft.SharePoint.Utilities;
...
string strISODate = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now)

20
.Net'iniz yeterince Java olmadığında SharePoint.
Henrik

18
Bunun için SharePoint kullanmak, bir jöle küveti, ıslak bir kibrit kutusu ve 2 trapez yürüyen şempanzeyi silahlı kavgaya getirmek gibidir.
nathanchere

SharePoint'te bile umarım BCL'leri .ToString("o")veya daha iyisini kullanabilirsiniz $"My complicated string {dt:o}".
binki

2

Bir API kullanımının URI'sinde geçirilebilen 2018-06-22T13: 04: 16 gibi formatlamak için:

public static string FormatDateTime(DateTime dateTime)
{
    return dateTime.ToString("s", System.Globalization.CultureInfo.InvariantCulture);
}

1
Bu ISO tarih dizesinin tanım başına kültür değişmez olduğunu düşünüyorum.
Jonas

1

Diğer cevapta belirtildiği gibi, DateTimetasarımla ilgili sorunlar var.

NodaTime

Tarih / saat değerlerini yönetmek için NodaTime kullanmanızı öneririm :

  • Yerel saat, tarih, tarih
  • Küresel zaman
  • Saat dilimi ile zaman
  • dönem
  • süre

Biçimlendirme

Bu nedenle, oluşturmak ve biçimlendirmek ZonedDateTimeiçin aşağıdaki kod snippet'ini kullanabilirsiniz:

var instant1 = Instant.FromUtc(2020, 06, 29, 10, 15, 22);

var utcZonedDateTime = new ZonedDateTime(instant1, DateTimeZone.Utc);
utcZonedDateTime.ToString("yyyy-MM-ddTHH:mm:ss'Z'", CultureInfo.InvariantCulture);
// 2020-06-29T10:15:22Z


var instant2 = Instant.FromDateTimeUtc(new DateTime(2020, 06, 29, 10, 15, 22, DateTimeKind.Utc));

var amsterdamZonedDateTime = new ZonedDateTime(instant2, DateTimeZoneProviders.Tzdb["Europe/Amsterdam"]);
amsterdamZonedDateTime.ToString("yyyy-MM-ddTHH:mm:ss'Z'", CultureInfo.InvariantCulture);
// 2020-06-29T12:15:22Z

Benim için NodaTimekod oldukça ayrıntılı görünüyor. Ancak türler gerçekten faydalıdır. Tarih / saat değerlerinin doğru şekilde işlenmesine yardımcı olurlar.

Newtonsoft.Json

Kullanmak için NodaTimebirlikte Newtonsoft.Jsonsize başvurusunu eklemeniz gerekir NodaTime.Serialization.JsonNetNuget paket ve yapılandırmak JSON seçenekleri.

services
    .AddMvc()
    .AddJsonOptions(options =>
    {
        var settings=options.SerializerSettings;
        settings.DateParseHandling = DateParseHandling.None;
        settings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
    });
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.