मैंने स्टैकओवरफ्लो के आसपास देखा है, और यहां तक कि कुछ सुझाए गए प्रश्नों को भी देखा है और कोई भी उत्तर नहीं देता है, तो आप C # में एक यूनिक्स टाइमस्टैम्प कैसे प्राप्त करते हैं?
जवाबों:
आपको DateTime.UtcNow1970-01-01 के युग के समय का उपयोग करके और घटाकर C # में एक यूनिक्स टाइमस्टैम्प प्राप्त होता है ।
जैसे
Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;DateTime.UtcNowकिसी भी ऐसी DateTimeवस्तु से प्रतिस्थापित किया जा सकता है जिसे आप यूनिक्स टाइमस्टैम्प के लिए प्राप्त करना चाहते हैं।
एक क्षेत्र भी है DateTime.UnixEpoch, जो MSFT द्वारा बहुत खराब दस्तावेज है, लेकिन इसका विकल्प हो सकता हैnew DateTime(1970, 1, 1)
DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).Ticks / TimeSpan.TicksPerSecond;
.NET 4.6 के रूप में, वहाँ है DateTimeOffset.ToUnixTimeSeconds()।
यह एक इंस्टेंस विधि है, इसलिए आपको इसे इंस्टेंस पर कॉल करने की उम्मीद है DateTimeOffset। आप किसी भी उदाहरण को भी डाल सकते हैं DateTime, हालांकि टाइमजोन से सावधान रहें ।
वर्तमान टाइमस्टैम्प प्राप्त करने के लिए:
DateTimeOffset.UtcNow.ToUnixTimeSeconds()एक से टाइमस्टैम्प प्राप्त करने के लिए DateTime:
DateTime foo = DateTime.UtcNow;
long unixTime = ((DateTimeOffset)foo).ToUnixTimeSeconds();Int64उस समय तक वापस लौटता है जब तक हम पृथ्वी की कमी के लिए पृथ्वी के वर्षों का उपयोग नहीं करेंगे।
DateTimeOffset.Now.ToUnixTimeSeconds()
आप टिक्स का भी उपयोग कर सकते हैं। मैं विंडोज़ मोबाइल के लिए कोडिंग कर रहा हूँ ताकि विधियों का पूरा सेट न हो। TotalSeconds मेरे लिए उपलब्ध नहीं है।
long epochTicks = new DateTime(1970, 1, 1).Ticks;
long unixTime = ((DateTime.UtcNow.Ticks - epochTicks) / TimeSpan.TicksPerSecond);या
TimeSpan epochTicks = new TimeSpan(new DateTime(1970, 1, 1).Ticks);
TimeSpan unixTicks = new TimeSpan(DateTime.UtcNow.Ticks) - epochTicks;
double unixTime = unixTicks.TotalSeconds;new DateTime(1970, 1, 1)अनिर्दिष्ट Kindसंपत्ति के साथ एक समय बनाता है । क्या आप वास्तव में new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)सही होना चाहते हैं
यही है वह जो मेरे द्वारा उपयोग किया जाता है:
public long UnixTimeNow()
{
var timeSpan = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
return (long)timeSpan.TotalSeconds;
}ध्यान रखें कि यह विधि समन्वित यूनीवर्सल टाइम (UTC) के रूप में समय लौटाएगी।
doubleटाइप है, इसे लंबे समय तक कास्ट करने से सटीक नुकसान होगा।)
छोटा किया जा रहा .TotalSeconds महत्वपूर्ण है क्योंकि इसे परिभाषित किया गया हैthe value of the current System.TimeSpan structure expressed in whole fractional seconds.
और कैसे के लिए एक विस्तार के बारे में DateTime? दूसरा शायद अधिक भ्रमित है कि यह तब तक लायक है जब तक कि संपत्ति एक्सटेंशन मौजूद नहीं है।
/// <summary>
/// Converts a given DateTime into a Unix timestamp
/// </summary>
/// <param name="value">Any DateTime</param>
/// <returns>The given DateTime in Unix timestamp format</returns>
public static int ToUnixTimestamp(this DateTime value)
{
return (int)Math.Truncate((value.ToUniversalTime().Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}
/// <summary>
/// Gets a Unix timestamp representing the current moment
/// </summary>
/// <param name="ignored">Parameter ignored</param>
/// <returns>Now expressed as a Unix timestamp</returns>
public static int UnixTimestamp(this DateTime ignored)
{
return (int)Math.Truncate((DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds);
}जब आप मौजूदा समय से 1970 घटाते हैं, तो ध्यान रखें कि टाइमपेन में सबसे अधिक बार गैर शून्य मिलीसेकंड फ़ील्ड होगी। यदि किसी कारण से आप मिलीसेकंड में रुचि रखते हैं, तो इसे ध्यान में रखें।
यहाँ है कि मैंने इस मुद्दे के आसपास क्या किया।
DateTime now = UtcNow();
// milliseconds Not included.
DateTime nowToTheSecond = new DateTime(now.Year,now.Month,now.Day,now.Hour,now.Minute,now.Second);
TimeSpan span = (date - new DateTime(1970, 1, 1, 0, 0, 0, 0));
Assert.That(span.Milliseconds, Is.EqualTo(0)); // passes.यही है वह जो मेरे द्वारा उपयोग किया जाता है।
public class TimeStamp
{
public Int32 UnixTimeStampUTC()
{
Int32 unixTimeStamp;
DateTime currentTime = DateTime.Now;
DateTime zuluTime = currentTime.ToUniversalTime();
DateTime unixEpoch = new DateTime(1970, 1, 1);
unixTimeStamp = (Int32)(zuluTime.Subtract(unixEpoch)).TotalSeconds;
return unixTimeStamp;
}
}मैंने इस उपयोगिता पद्धति के सबसे सुरुचिपूर्ण तरीकों को एक साथ जोड़ा है:
public static class Ux {
public static decimal ToUnixTimestampSecs(this DateTime date) => ToUnixTimestampTicks(date) / (decimal) TimeSpan.TicksPerSecond;
public static long ToUnixTimestampTicks(this DateTime date) => date.ToUniversalTime().Ticks - UnixEpochTicks;
private static readonly long UnixEpochTicks = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
}इस समाधान से मेरी स्थिति में मदद मिली:
public class DateHelper {
public static double DateTimeToUnixTimestamp(DateTime dateTime)
{
return (TimeZoneInfo.ConvertTimeToUtc(dateTime) -
new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).TotalSeconds;
}
}कोड में सहायक का उपयोग करना:
double ret = DateHelper.DateTimeToUnixTimestamp(DateTime.Now)सिस्टम में DateTimeOffset के लिए एक ToUnixTimeMilliseconds है
आप DateTime के लिए समान विधि लिख सकते हैं:
public static long ToUnixTimeSeconds(this DateTime value)
{
return value.Ticks / 10000000L - 62135596800L;
}10000000L - टिक को सेकंड में परिवर्तित करना
62135596800L - 01.01.01 से 01.01.1978 तक परिवर्तित
Utc और लीक से कोई समस्या नहीं है
नीचे एक 2-तरफ़ा एक्सटेंशन क्लास है जो समर्थन करता है:
ओपी के मामले में, उपयोग है:
DateTime.Now.ToUnixtime();या
DateTime.UtcNow.ToUnixtime();हालांकि एक सीधा जवाब मौजूद है, मेरा मानना है कि सामान्य दृष्टिकोण का उपयोग करना बेहतर है। विशेष रूप से क्योंकि यह सबसे अधिक संभावना है कि इस तरह के रूपांतरण की आवश्यकता है, वैसे भी इन एक्सटेंशनों की आवश्यकता होगी, इसलिए सभी के लिए एक ही उपकरण का उपयोग करना बेहतर है।
public static class UnixtimeExtensions
{
public static readonly DateTime UNIXTIME_ZERO_POINT = new DateTime(1970, 1, 1, 0, 0,0, DateTimeKind.Utc);
/// <summary>
/// Converts a Unix timestamp (UTC timezone by definition) into a DateTime object
/// </summary>
/// <param name="value">An input of Unix timestamp in seconds or milliseconds format</param>
/// <param name="localize">should output be localized or remain in UTC timezone?</param>
/// <param name="isInMilliseconds">Is input in milliseconds or seconds?</param>
/// <returns></returns>
public static DateTime FromUnixtime(this long value, bool localize = false, bool isInMilliseconds = true)
{
DateTime result;
if (isInMilliseconds)
{
result = UNIXTIME_ZERO_POINT.AddMilliseconds(value);
}
else
{
result = UNIXTIME_ZERO_POINT.AddSeconds(value);
}
if (localize)
return result.ToLocalTime();
else
return result;
}
/// <summary>
/// Converts a DateTime object into a Unix time stamp
/// </summary>
/// <param name="value">any DateTime object as input</param>
/// <param name="isInMilliseconds">Should output be in milliseconds or seconds?</param>
/// <returns></returns>
public static long ToUnixtime(this DateTime value, bool isInMilliseconds = true)
{
if (isInMilliseconds)
{
return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalMilliseconds;
}
else
{
return (long)value.ToUniversalTime().Subtract(UNIXTIME_ZERO_POINT).TotalSeconds;
}
}
}मैं थोड़ी देर के लिए संघर्ष करने के बाद इसका इस्तेमाल किया, यह timezone ऑफसेट के रूप में अच्छी तरह से पूरा करता है:
public double Convert_DatTime_To_UNIXDATETIME(DateTime dt)
{
System.DateTime from_date = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
double unix_time_since = dt.Subtract(from_date).TotalMilliseconds;
TimeSpan ts_offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow);
double offset = ts_offset.TotalMilliseconds;
return unix_time_since - offset;
}सरल कोड जो मैं उपयोग कर रहा हूं:
public static long CurrentTimestamp()
{
return (long)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds * 1000);
}यह कोड यूनिक्स टाइमस्टैम्प, कुल मिला कर 1970-01-01 से अब तक का है।