मैं यूनिक्स टाइमस्टैम्प को डेटटाइम में कैसे बदल सकता हूं और इसके विपरीत?

Question

यह उदाहरण कोड है, लेकिन फिर यह मिलीसेकंड / नैनोसेकंड समस्याओं के बारे में बात करना शुरू कर देता है।

यही सवाल MSDN पर है, C # में यूनिक्स के युग से ।

यह वही है जो मैंने अब तक प्राप्त किया है:

public Double CreatedEpoch
{
  get
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    TimeSpan span = (this.Created.ToLocalTime() - epoch);
    return span.TotalSeconds;
  }
  set
  {
    DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0).ToLocalTime();
    this.Created = epoch.AddSeconds(value);
  }
}

Comments

आगामी .NET 4.6 (इस वर्ष के अंत में रिलीज़ होने के लिए) इसके लिए समर्थन का परिचय देता है। देखें DateTimeOffset.FromUnixTimeSecondsऔर DateTimeOffset.ToUnixTimeSecondsतरीके। मिलीसेकंड यूनिक्स-टाइम के लिए भी तरीके हैं।

— जेपी स्टिग नीलसन

Answer 1

यहाँ आपको क्या चाहिए:

public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )
{
    // Unix timestamp is seconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();
    return dtDateTime;
}

या, जावा के लिए (जो कि भिन्न है क्योंकि टाइमसेकंड मिलीसेकंड में है, सेकंड नहीं):

public static DateTime JavaTimeStampToDateTime( double javaTimeStamp )
{
    // Java timestamp is milliseconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddMilliseconds( javaTimeStamp ).ToLocalTime();
    return dtDateTime;
}

Comments

विंडोज में समय एचएएल द्वारा संभाला जाता है और 1ms से 15ms के भीतर केवल पास-सटीक होता है। अधिक जानकारी विंडोज इंटर्नल में पेज 112 के आसपास उपलब्ध है , अगर कोई दिलचस्पी रखता है।

— जिम स्कुबर्ट

यह जवाब सेकंडों को रौंदने का जोखिम है ... एक डबल एक फ्लोटिंग नंबर है। तर्क इंट / लॉन्ग / वगैरह होना चाहिए।

— ccook

इन तरीकों को एक लंबे या इंट को स्वीकार करना चाहिए, एक डबल को नहीं। इसके अलावा, जावा टाइम स्टैम्प के लिए, 1000 और राउंड को विभाजित करने की आवश्यकता नहीं है। बस करते हैंdtDateTime.AddMilliseconds(javaTimeStamp).ToLocalTime();

— जस्टिन जॉनसन

क्या आपको बस "इसके विपरीत" याद आया? हम एक DateTime को टाइमस्टैम्प में कैसे परिवर्तित करते हैं?

— जॉनी

.NET फ्रेमवर्क के लिए 4.6 और इसके बाद के संस्करण अब static DateTimeOffset.FromUnixMillisecondsऔर है DateTimeOffset.ToUnixMilliseconds।

— रॉकी 1024

Answer 2

.NET (v4.6) के नवीनतम संस्करण को जोड़ा गया है में निर्मित यूनिक्स समय रूपांतरण के लिए समर्थन करते हैं। इसमें यूनिक्स समय से लेकर सेकंड या मिली सेकेंड तक, दोनों शामिल हैं।

• यूटीसी के सेकंड में यूनिक्स समय DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(1000);

• DateTimeOffset सेकंड में यूनिक्स समय:

long unixTimeStampInSeconds = dateTimeOffset.ToUnixTimeSeconds();

• यूटीसी को मिलीसेकंड में यूनिक्स समय DateTimeOffset:

DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(1000000);

• DateTimeOffset मिलीसेकंड में यूनिक्स समय:

long unixTimeStampInMilliseconds = dateTimeOffset.ToUnixTimeMilliseconds();

---

नोट: ये विधियाँ यूटीसी से और इससे परिवर्तित होती हैं DateTimeOffset। DateTimeप्रतिनिधित्व प्राप्त करने के लिए बस DateTimeOffset.UtcDateTimeया DateTimeOffset.LocalDateTimeगुणों का उपयोग करें :

DateTime dateTime = dateTimeOffset.UtcDateTime;

Comments

docs.microsoft.com/en-us/dotnet/api/…

— yedevtxt

यह समय को स्थानीय समय में परिवर्तित नहीं करता है। यदि आप DateTimeOffset.FromUnixTimeSeconds () का उपयोग करते हैं तो आपको UTC मिलता है।

— बेरेंड डी बोअर

@BerenddeBoer आप चाहें ToLocalTimeतो उपयोग कर सकते हैं।

— i3arnon

वर्तमान समय प्राप्त करने के लिए आप उपयोग कर सकते हैंlong unixMilliseconds = DateTimeOffset.Now.ToUnixTimeMilliseconds();

— Dan Diplo

Answer 3

UNIX टाइमस्टैम्प के लिए दिनांक समय:

public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
    return (TimeZoneInfo.ConvertTimeToUtc(dateTime) - 
           new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).TotalSeconds;
}

Answer 4

से विकिपीडिया :

यूटीसी मौसम के बदलाव के साथ नहीं बदलता है, लेकिन यदि समय क्षेत्र अधिकार क्षेत्र दिन के समय की बचत (गर्मी का समय) को देखता है तो स्थानीय समय या नागरिक समय बदल सकता है। उदाहरण के लिए, संयुक्त राज्य अमेरिका के पूर्वी तट पर स्थानीय समय सर्दियों के दौरान यूटीसी से पांच घंटे पीछे है, लेकिन चार घंटे पीछे जबकि दिन के उजाले में बचत होती है।

तो यह मेरा कोड है:

TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0,DateTimeKind.Utc));
double unixTime = span.TotalSeconds;

Comments

लेकिन यह एक दोगुना रिटर्न देता है, मुझे लगता है कि किसी को लंबे समय तक कास्ट करने की जरूरत है?

— knocte

Answer 5

सावधान रहें, यदि आपको मिलीसेकंड से अधिक सटीकता की आवश्यकता है!

.NET (v4.6) विधियाँ (उदा। FromUnixTimeMilliseconds ) यह सटीकता प्रदान नहीं करती हैं।

AddSeconds और AddMilliseconds ने भी डबल में माइक्रोसेकंड को काट दिया।

इन संस्करणों में उच्च परिशुद्धता है:

यूनिक्स -> दिनांक समय

public static DateTime UnixTimestampToDateTime(double unixTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (long) (unixTime * TimeSpan.TicksPerSecond);
    return new DateTime(unixStart.Ticks + unixTimeStampInTicks, System.DateTimeKind.Utc);
}

दिनांक समय -> यूनिक्स

public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
    DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
    long unixTimeStampInTicks = (dateTime.ToUniversalTime() - unixStart).Ticks;
    return (double) unixTimeStampInTicks / TimeSpan.TicksPerSecond;
}

Comments

यह सही जवाब है। दूसरों को टाइमस्टैम्प से वापस कन्वर्ट पर गलत समय क्षेत्र मिलता है।

— IAMIC

DateTime-> Java के लिए, बस [कोड] वापसी (लंबी) unixTimeStampInTicks / TimeSpan.TicksPerMilliSecond; [/ कोड]

— मैक्स

तो आप में UnixTimestampToDateTime, आपूर्ति unixTimeअभी भी सेकंड में है, है ना?

— नगोक फाम

@NgocPham हाँ यह है

— फेलिक्स कील

Answer 6

IdentityModel.EpochTimeExtensions देखें

public static class EpochTimeExtensions
{
    /// <summary>
    /// Converts the given date value to epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTime dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given date value to epoch time.
    /// </summary>
    public static long ToEpochTime(this DateTimeOffset dateTime)
    {
        var date = dateTime.ToUniversalTime();
        var ticks = date.Ticks - new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).Ticks;
        var ts = ticks / TimeSpan.TicksPerSecond;
        return ts;
    }

    /// <summary>
    /// Converts the given epoch time to a <see cref="DateTime"/> with <see cref="DateTimeKind.Utc"/> kind.
    /// </summary>
    public static DateTime ToDateTimeFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddTicks(timeInTicks);
    }

    /// <summary>
    /// Converts the given epoch time to a UTC <see cref="DateTimeOffset"/>.
    /// </summary>
    public static DateTimeOffset ToDateTimeOffsetFromEpoch(this long intDate)
    {
        var timeInTicks = intDate * TimeSpan.TicksPerSecond;
        return new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddTicks(timeInTicks);
    }
}

Comments

यह अच्छा है, लेकिन मैं एक छोटे से बदलाव का सुझाव दूंगा: टाइप का उपयोग "लंबे" को "इंट 32" या "इंट" में बदल दिया जाना चाहिए। "लॉन्ग" का तात्पर्य महत्वपूर्ण परिशुद्धता है, लेकिन वहाँ नहीं है। गणित के सभी केवल 1 सेकंड के लिए सटीक है, इसलिए Int32 आप यूनिक्स टाइमस्टैम्प से क्या उम्मीद करेंगे के अधिक विचारोत्तेजक होगा

— JamesHoux

मुझे लगता है कि यह DateTime.TicksInt64 (लंबा) होने के कारण है , इसलिए वे एक अतिरिक्त अनियंत्रित डाली से बच रहे हैं।

— orad

Answer 7

ScottCher के उत्तर के पूरक के लिए, मैंने हाल ही में खुद को एक इनपुट डेटा सेट में मनमाने ढंग से एक साथ मिश्रित सेकंड और मिलीसेकंड UNIX टाइमस्टैम्प दोनों होने के कष्टप्रद परिदृश्य में पाया। निम्न कोड यह अच्छी तरह से संभालने के लिए लगता है:

static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
static readonly double MaxUnixSeconds = (DateTime.MaxValue - UnixEpoch).TotalSeconds;

public static DateTime UnixTimeStampToDateTime(double unixTimeStamp)
{
   return unixTimeStamp > MaxUnixSeconds
      ? UnixEpoch.AddMilliseconds(unixTimeStamp)
      : UnixEpoch.AddSeconds(unixTimeStamp);
}

Comments

DateTimeKind तर्क का उपयोग नहीं करते समय सावधान रहें, क्योंकि निर्मित समयदिनांक कंप्यूटर के स्थानीय समय में होगा (कोड के लिए धन्यवाद, क्रिस)!

— सैम ग्रोनडाल

खबरदार - यह 11 जनवरी 1978 से पहले की तारीखों के लिए यूनिक्स टाइमस्टैम्प के लिए काम नहीं करेगा यदि वे मिलीसेकंड में प्रतिनिधित्व करते हैं। 253324800 (सेकंड) का यूनिक्स डेटस्टैम्प 11.01.1978 की सही तारीख देता है, जबकि मिलिसकॉन्ड प्रतिनिधित्व 253324800000 18.07.9997 की तारीख देता है। यह आपके डेटा सेट के लिए काम कर सकता है, लेकिन यह एक सामान्य समाधान नहीं है।

— .यविन्द

Answer 8

.NET फ्रेमवर्क 4.6 में यूनिक्स समय रूपांतरण नया है।

अब आप अधिक आसानी से दिनांक और समय मानों को .NET फ्रेमवर्क प्रकारों और यूनिक्स समय से या उससे बदल सकते हैं। यह आवश्यक हो सकता है, उदाहरण के लिए, जब जावास्क्रिप्ट क्लाइंट और .NET सर्वर के बीच समय मान परिवर्तित करते हैं। निम्न API को DateTimeOffset संरचना में जोड़ा गया है :

static DateTimeOffset FromUnixTimeSeconds(long seconds)
static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
long DateTimeOffset.ToUnixTimeSeconds()
long DateTimeOffset.ToUnixTimeMilliseconds()

Comments

यह आपको स्थानीय समय नहीं देता है, आपको यूटीसी मिलता है।

— बेरेंड डी बोअर

@BerenddeBoer यह एक उचित डिफ़ॉल्ट है। आप इसके बाद एक कस्टम ऑफसेट लागू कर सकते हैं जैसा आप चाहते हैं।

— 13

@BerenddeBoer कि यूनिक्स समय क्या गलतफहमी है। यूनिक्स का समय आधी रात, 1 जनवरी, 1970, यूटीसी के बाद से सेकंड है। इससे कोई फर्क नहीं पड़ता कि आप कहां हैं, सेकंड की संख्या के बाद से वह युग नहीं बदलता है। इसे मानव पठनीय स्थानीय समय डिस्प्ले में परिवर्तित करना इस सार्वभौमिक प्रतिनिधित्व से अलग है, जैसा कि यह होना चाहिए।

— टंकटालस

Answer 9

मैंने केवल स्थानीय समय समायोजन 1/1/1970 w / o में रूपांतरण की तुलना करके सही उत्तर पाया;

DateTime date = new DateTime(2011, 4, 1, 12, 0, 0, 0);
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);
TimeSpan span = (date - epoch);
double unixTime =span.TotalSeconds;

Answer 10

var dt = DateTime.Now; 
var unixTime = ((DateTimeOffset)dt).ToUnixTimeSeconds();

// 1510396991

var dt = DateTimeOffset.FromUnixTimeSeconds(1510396991);

// [11.11.2017 10:43:11 +00: 00]

Answer 11

.Net 4.6 से, आप यह कर सकते हैं:

var dateTime = DateTimeOffset.FromUnixTimeSeconds(unixDateTime).DateTime;

Answer 12

DateTime unixEpoch = DateTime.ParseExact("1970-01-01", "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture);
DateTime convertedTime = unixEpoch.AddMilliseconds(unixTimeInMillisconds);

बेशक, unixEpochकोई वैश्विक स्थैतिक बना सकता है , इसलिए इसे केवल एक बार आपकी परियोजना में प्रदर्शित होने की आवश्यकता है, और AddSecondsयदि यूनिक्स का समय सेकंड में है, तो कोई भी इसका उपयोग कर सकता है।

दूसरे रास्ते पर जाने के लिए:

double unixTimeInMilliseconds = timeToConvert.Subtract(unixEpoch).TotalMilliseconds;

Int64 और / या TotalSecondsजरूरत के रूप में उपयोग करने के लिए काटें ।

Answer 13

एक सरलतम विस्तार लिखा जो हमारे लिए काम करता है। अगर किसी को इसकी तलाश है ...

public static class DateTimeExtensions
{
    public static DateTime FromUnixTimeStampToDateTime(this string unixTimeStamp)
    {

        return DateTimeOffset.FromUnixTimeSeconds(long.Parse(unixTimeStamp)).UtcDateTime;
    }
}

Answer 14

System.DateTimeOffset.Now.ToUnixTimeSeconds()

Answer 15

एक यूनिक्स टिक 1 सेकंड (यदि मुझे अच्छी तरह याद है), और एक .NET टिक 100 नैनोसेकंड है।

यदि आप नैनोसेकंड के साथ समस्याओं का सामना कर रहे हैं, तो आप AddTick (10000000 * मान) का उपयोग करने का प्रयास कर सकते हैं।

Comments

यूनिक्स पिछले कुछ सेकंड है - जो 1/1/70 है।

— स्कॉटकर

Answer 16

मैं एक बदलने की जरूरत timeval struct (सेकंड, माइक्रोसेकंड) युक्त UNIX timeकरने के लिए DateTimeसटीक खोने के बिना और यहाँ एक जवाब नहीं मिला है तो मैं मैं सिर्फ मेरा जोड़ सकते हैं सोचा:

DateTime _epochTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
private DateTime UnixTimeToDateTime(Timeval unixTime)
{
    return _epochTime.AddTicks(
        unixTime.Seconds * TimeSpan.TicksPerSecond +
        unixTime.Microseconds * TimeSpan.TicksPerMillisecond/1000);
}

Answer 17

आप DateTimeOffset का उपयोग कर सकते हैं ।

उदाहरण के लिए। मेरे पास DateTime ऑब्जेक्ट है

var dateTime=new DateTime();

अगर मैं इसे यूनिक्स टाइम स्टैम्प में बदलना चाहता हूं, तो मुझे निम्न प्रकार से प्राप्त किया जा सकता है

var unixTimeSeconds= new DateTimeOffset(dateTime).ToUnixTimeSeconds()

अधिक जानकारी के लिए कृपया इस लिंक पर जाएँ: DateTimeOffset.ToUnixTimeSeconds Method

Answer 18

public static class UnixTime
    {
        private static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);

        public static DateTime UnixTimeToDateTime(double unixTimeStamp)
        {
            return Epoch.AddSeconds(unixTimeStamp).ToUniversalTime();
        }
    }

आप UnixTime.UnixTimeToDateTime (दोहरा डेटाटाइम) को कॉल कर सकते हैं)

Answer 19

.NET 4.6 और बाद के लिए:

public static class UnixDateTime
{
    public static DateTimeOffset FromUnixTimeSeconds(long seconds)
    {
        if (seconds < -62135596800L || seconds > 253402300799L)
            throw new ArgumentOutOfRangeException("seconds", seconds, "");

        return new DateTimeOffset(seconds * 10000000L + 621355968000000000L, TimeSpan.Zero);
    }

    public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
    {
        if (milliseconds < -62135596800000L || milliseconds > 253402300799999L)
            throw new ArgumentOutOfRangeException("milliseconds", milliseconds, "");

        return new DateTimeOffset(milliseconds * 10000L + 621355968000000000L, TimeSpan.Zero);
    }

    public static long ToUnixTimeSeconds(this DateTimeOffset utcDateTime)
    {
        return utcDateTime.Ticks / 10000000L - 62135596800L;
    }

    public static long ToUnixTimeMilliseconds(this DateTimeOffset utcDateTime)
    {
        return utcDateTime.Ticks / 10000L - 62135596800000L;
    }

    [Test]
    public void UnixSeconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInSeconds = utcNowOffset.ToUnixTimeSeconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeSeconds(unixTimestampInSeconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
    }

    [Test]
    public void UnixMilliseconds()
    {
        DateTime utcNow = DateTime.UtcNow;
        DateTimeOffset utcNowOffset = new DateTimeOffset(utcNow);

        long unixTimestampInMilliseconds = utcNowOffset.ToUnixTimeMilliseconds();

        DateTimeOffset utcNowOffsetTest = UnixDateTime.FromUnixTimeMilliseconds(unixTimestampInMilliseconds);

        Assert.AreEqual(utcNowOffset.Year, utcNowOffsetTest.Year);
        Assert.AreEqual(utcNowOffset.Month, utcNowOffsetTest.Month);
        Assert.AreEqual(utcNowOffset.Date, utcNowOffsetTest.Date);
        Assert.AreEqual(utcNowOffset.Hour, utcNowOffsetTest.Hour);
        Assert.AreEqual(utcNowOffset.Minute, utcNowOffsetTest.Minute);
        Assert.AreEqual(utcNowOffset.Second, utcNowOffsetTest.Second);
        Assert.AreEqual(utcNowOffset.Millisecond, utcNowOffsetTest.Millisecond);
    }
}

Comments

मुझे समझ नहीं आता। .NET 4.6 में, BCL के पास पहले से ही वो विधियां हैं (उदाहरण के लिए ऊपर दिए गए प्रश्न पर मेरी टिप्पणी देखें, या कुछ अन्य नए (2015))। तो उन्हें फिर से लिखने में क्या बिंदु होना चाहिए? 4.6 से पहले के संस्करणों के लिए एक समाधान ?

— जेपी स्टिग नील्सन