আমি কীভাবে কোনও ইউনিক্স টাইমস্ট্যাম্পকে ডেটটাইম এবং তার বিপরীতে রূপান্তর করতে পারি?

Question

এই উদাহরণ কোড আছে, কিন্তু তারপর এটি মিলিসেকেন্ড / ন্যানোসেকেন্ড সমস্যা সম্পর্কে কথা বলা শুরু করে।

একই প্রশ্নটি এমএসডিএন, সেকেন্ডস সিএন-তে ইউনিক্সের সূচনা হওয়ার পরে ।

আমি এ পর্যন্ত এটি পেয়েছি:

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

উইন্ডোজের সময়টি এইচএল দ্বারা পরিচালিত হয় এবং কেবলমাত্র 1 মিমি থেকে 15 মিমি অবধি-নিকট-সঠিক accurate যদি কেউ আগ্রহী হন তবে 112 পৃষ্ঠার চারপাশে উইন্ডোজ ইন্টারনালগুলিতে আরও তথ্য উপলব্ধ ।

— জিম শুবার্ট

এই উত্তরটি কয়েক সেকেন্ড ছাঁটাই ঝুঁকিপূর্ণ ... একটি ডাবল একটি ভাসমান সংখ্যা। যুক্তিটি দীর্ঘ / দীর্ঘ / ইত্যাদি হওয়া উচিত।

— ccook

এই পদ্ধতিগুলির একটি দীর্ঘ বা int গ্রহণ করা উচিত, একটি ডাবল নয়। এছাড়াও, জাভা টাইম স্ট্যাম্পগুলির জন্য, 1000 এবং রাউন্ড দিয়ে ভাগ করার দরকার নেই। ঠিক করুনdtDateTime.AddMilliseconds(javaTimeStamp).ToLocalTime();

— জাস্টিন জনসন

আপনি কি ঠিক "বিপরীত" মিস করেছেন? আমরা কীভাবে একটি ডেটটাইমকে একটি টাইমস্ট্যাম্পে রূপান্তর করব?

— জনি

.NET ফ্রেমওয়ার্ক 4.6 এবং এর উপরে এখন static DateTimeOffset.FromUnixMillisecondsএবং আছে DateTimeOffset.ToUnixMilliseconds।

— rookie1024

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

ডকস.মাইক্রোসফট.ওন

— ডটনেট /

এটি স্থানীয় সময়কে রূপান্তর করে না। আপনি ইউটিসি পাবেন যদি আপনি ডেটটাইমঅফসেট ব্যবহার করেন Fফর্ম ইউনিক্সটাইমসেকেন্ডস ()।

— বেরেন্ড দে বোয়ার

@ বেরেন্ডদেবোর আপনি চাইলে ব্যবহার ToLocalTimeকরতে পারেন।

— i3arnon

বর্তমান সময় আপনি ব্যবহার করতে পারেনlong unixMilliseconds = DateTimeOffset.Now.ToUnixTimeMilliseconds();

— ড্যান ডিপ্লো

Answer 3

ইউনিক্স টাইমস্ট্যাম্প থেকে ডেটটাইম:

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

উইকিপিডিয়া থেকে :

ইউটিসি seতু পরিবর্তনের সাথে পরিবর্তিত হয় না, তবে কোনও সময় অঞ্চল এখতিয়ারে দিবালোক সংরক্ষণের সময় (গ্রীষ্মের সময়) পর্যবেক্ষণ করলে স্থানীয় সময় বা নাগরিক সময় পরিবর্তন হতে পারে। উদাহরণস্বরূপ, মার্কিন যুক্তরাষ্ট্রের পূর্ব উপকূলে স্থানীয় সময় শীতকালে ইউটিসির পিছনে পাঁচ ঘন্টা, তবে সেখানে দিনের আলো সংরক্ষণের সময় চার ঘন্টা পিছনে থাকে।

সুতরাং এটি আমার কোড:

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

Comments

তবে এটি একটি ডাবল ফেরত দেয়, আমি অনুমান করি যে দীর্ঘায়িত হওয়া দরকার?

— নোকট করুন

Answer 5

সতর্কতা অবলম্বন করুন, যদি আপনার মিলিসেকেন্ডের চেয়ে উচ্চতর নির্ভুলতা প্রয়োজন হয়!

.NET (v4.6) পদ্ধতিগুলি (যেমন: ইউনিক্সটাইমমিলিসেকেন্ডগুলি ) এই নির্ভুলতা সরবরাহ করে না।

অ্যাডসেকেন্ডস এবং অ্যাডমিলিসেকেন্ডগুলি ডাবলটিতে মাইক্রোসেকেন্ডগুলি কেটে দেয়।

এই সংস্করণগুলিতে উচ্চ নির্ভুলতা রয়েছে:

ইউনিক্স -> ডেটটাইম

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

ডেটটাইম-> জাভার জন্য, কেবল [কোড] রিটার্ন (দীর্ঘ) ইউনিক্সটাইমস্ট্যাম্পটাইটিক্স / টাইমস্প্যান.টিক্সপিরমিলি সেকেন্ড; [/ কোড]

— সর্বাধিক

আপনার মধ্যে UnixTimestampToDateTime, সরবরাহ unixTimeকরা এখনও কয়েক সেকেন্ডের মধ্যে আছে, তাই না?

— এনগোক ফ্যাম 21

@ নগোকফ্যাম হ্যাঁ

— ফেলিক্স কেইল

Answer 6

আইডেন্টিটি মডেল.এপোচটাইম এক্সটেনশনগুলি দেখুন

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 সেকেন্ডের জন্য নির্ভুল তাই অন্তর্গত 32 টি আপনি ইউনিক্স টাইমস্ট্যাম্পের কাছ থেকে যা প্রত্যাশা করতেন সে সম্পর্কে আরও পরামর্শ দেওয়া হবে

— জেমসহক্স

আমি মনে করি এটি DateTime.Ticksইন্টার 64৪ (দীর্ঘ) হওয়ার কারণে , সুতরাং তারা একটি অতিরিক্ত চেক না করা avoালাই এড়ানো হচ্ছে।

— ওড়াদ

Answer 7

স্কটচরের উত্তরকে পরিপূরক করতে আমি সম্প্রতি নিজেকে একটি ইনপুট ডেটা সেটে সেকেন্ড এবং মিলিসেকেন্ড ইউএনআইএক্স টাইমস্ট্যাম্পগুলি নির্বিচারে একত্রে মিশ্রিত করার বিরক্তিকর দৃশ্যে পেয়েছি। নিম্নলিখিত কোডটি এটি ভালভাবে পরিচালনা করছে বলে মনে হচ্ছে:

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

ডেটটাইমকাইন্ড আর্গুমেন্টটি ব্যবহার না করার সময় সাবধান থাকবেন, যেহেতু তৈরি ডেটটাইম কম্পিউটারের স্থানীয় সময় হবে (কোডটির জন্য ধন্যবাদ, ক্রিস)!

— স্যাম গ্রোঁদহাল

সাবধান - এটি মিলিসেকেন্ডে প্রতিনিধিত্ব করা হলে 1978 সালের 11 ই জানুয়ারীর পূর্বের তারিখগুলির জন্য ইউনিক্স টাইমস্ট্যাম্পগুলির জন্য কাজ করবে না। 253324800 (সেকেন্ড) এর একটি ইউনিক্স ডেটস্ট্যাম্পটি 11.01.1978 এর সঠিক তারিখ দেয় তবে মিলিসেকেন্ডের উপস্থাপনা 253324800000 18.07.9997 তারিখ দেয়। এটি আপনার ডেটা সেটের জন্য কাজ করেছে, তবে এটি কোনও সাধারণ সমাধান নয়।

— vyvind

Answer 8

নেট ফ্রেমওয়ার্ক ৪.6-এ ইউনিক্সের সময় রূপান্তরটি নতুন।

আপনি এখন আরও সহজে NET ফ্রেমওয়ার্ক টাইপ এবং ইউনিক্স সময় থেকে তারিখ এবং সময় মান রূপান্তর করতে পারেন। এটি প্রয়োজনীয় হতে পারে, উদাহরণস্বরূপ, একটি জাভাস্ক্রিপ্ট ক্লায়েন্ট এবং .NET সার্ভারের মধ্যে সময়ের মান রূপান্তর করার সময়। নিম্নলিখিত API গুলি তারিখটাইম অফসেট কাঠামোতে যুক্ত করা হয়েছে :

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

Comments

এটি আপনাকে স্থানীয় সময় দেয় না, আপনি ইউটিসি পাবেন।

— বেরেন্ড দে বোয়ার

@ বেরেনডে বোয়ের এটি যুক্তিসঙ্গত ডিফল্ট। আপনি নিজের পছন্দ অনুসারে কাস্টম অফসেট প্রয়োগ করতে পারেন।

— দেিলান

@ বেরেনডে বোয়ের এটি ইউনিক্স সময় কী তা ভুল বুঝে। ইউনিক্স সময়টি মধ্যরাত, 1 জানুয়ারি, 1970, ইউটিসি থেকে সেকেন্ড is আপনি কোথায় আছেন তা বিবেচ্য নয়, সেই যুগের পর থেকে কয়েক সেকেন্ডের সংখ্যা পরিবর্তন হয় না। এটিকে মানুষের পাঠযোগ্য স্থানীয় সময় প্রদর্শনে রূপান্তর করা এই সার্বজনীন প্রতিনিধিত্ব থেকে পৃথক, যেমন হওয়া উচিত।

— টঙ্কটালাস

Answer 9

রূপান্তরটির সাথে 1/1/1970 ডাব্লু / ও স্থানীয় সময় সামঞ্জস্যের সাথে তুলনা করে আমি সঠিক উত্তরটি পেয়েছি;

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প্রয়োজন অনুসারে ব্যবহার করুন un

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 সেকেন্ডের (যদি আমি ভাল করে মনে করি), এবং একটি নেট টিকটি 100 ন্যানোসেকেন্ড হয়।

আপনি যদি ন্যানোসেকেন্ডে সমস্যা দেখা দিচ্ছেন, আপনি অ্যাডটিক (10000000 * মান) ব্যবহার করে দেখতে পারেন।

Comments

ইউনিক্স যুগের কয়েক সেকেন্ড আগের - যা 1/1/70।

— স্কটচের

Answer 16

আমার একটি টাইমওয়াল স্ট্রাক্ট (সেকেন্ড, মাইক্রোসেকেন্ডস) এতে রূপান্তর 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

আপনি ডেটটাইম অফসেট ব্যবহার করতে পারেন ।

উদাহরণ স্বরূপ. আমার ডেটটাইম অবজেক্ট আছে

var dateTime=new DateTime();

যদি আমি এটিকে ইউনিক্স টাইম স্ট্যাম্পগুলিতে রূপান্তর করতে চাই তবে আমি নিম্নলিখিত হিসাবে অর্জন করতে পারি

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

আরও তথ্যের জন্য দয়া করে এই লিঙ্কটি দেখুন: ডেটটাইমঅফসেট.টওউনিক্সটাইমসেকেন্ডস পদ্ধতি

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();
        }
    }

আপনি ইউনিক্সটাইম কল করতে পারেন Uউনিক্সটাইমটোডেটটাইম (ডাবল ডেটটাইম)

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

আমি বুঝতে পারছি না. নেট 4.. 4.-তে, ছাত্রলীগের ইতিমধ্যে সেগুলি রয়েছে (উদাহরণস্বরূপ উপরের প্রশ্নে আমার মন্তব্য, বা অন্য কিছু নতুন উত্তর (২০১৫) দেখুন writing তাই আবার তাদের লেখার অর্থ কী হওয়া উচিত? আপনি কি বোঝাতে চেয়েছিলেন যে আপনার উত্তরটি ছিল 4.6 এর আগে সংস্করণগুলির সমাধান ?

— জেপ্পে স্টিগ নীলসন