NET- এ কেবলমাত্র মানটিকে কীভাবে উপস্থাপন করব?


238

তারিখ ছাড়াই .NET- এ কেবলমাত্র কোনও সময়ের জন্য কোনও সময় উপস্থাপনের উপায় আছে কি? উদাহরণস্বরূপ, কোনও দোকানের খোলার সময়টি বোঝাচ্ছেন?

TimeSpanএকটি ব্যাপ্তি নির্দেশ করে, যেখানে আমি কেবল সময়ের মান সঞ্চয় করতে চাই। DateTimeএটি ইঙ্গিত করতে ব্যবহার করে এর ফলে নতুন ফলাফল আসবে DateTime(1,1,1,8,30,0)যা সত্যই কাম্য নয়।

উত্তর:


143

অন্যরা যেমন বলেছে, আপনি একটি ব্যবহার করতে পারেন DateTimeএবং তারিখটি উপেক্ষা করতে পারেন , বা একটি ব্যবহার করতে পারেন TimeSpan। ব্যক্তিগতভাবে আমি এই সমাধানগুলির কোনওটির জন্যই আগ্রহী নই, কারণ প্রকারভেদে কোনটিই সত্যিকার অর্থে যে ধারণাটি উপস্থাপন করার চেষ্টা করছেন তা প্রতিফলিত করে - আমি তারিখ / সময় প্রকারগুলিকে কিছুটা অপ্রয়োজনীয় দিক হিসাবে বিবেচনা করি যা আমি শুরু করার কারণগুলির মধ্যে কিছুটা নোদা সময় । নোদা সময়ে, আপনি LocalTimeদিনের একটি সময় উপস্থাপন করতে টাইপটি ব্যবহার করতে পারেন ।

একটি বিষয় বিবেচনা করতে হবে: দিনের সময় অগত্যা একই দিন মধ্যরাত থেকে সময়ের দৈর্ঘ্য নয় ...

(অন্য একটিকে বাদ দিয়ে, যদি আপনি কোনও দোকানের সমাপ্তির সময়কেও উপস্থাপন করতে চান, তবে আপনি দেখতে পাবেন যে আপনি 24:00, অর্থাৎ দিনের শেষে সময় উপস্থাপন করতে চান Most বেশিরভাগ তারিখ / সময়ের এপিআই - নোদা সহ সময় - এটি সময়ের-সময়ের মান হিসাবে উপস্থাপন করার অনুমতি দেবেন না))


5
"[টি] একই সাথে মধ্যরাতের পর থেকে দিনের সময় প্রয়োজন হয় না ..." দিবালোক সঞ্চয়ের সময় কি একমাত্র কারণ? আপনি কেন অনির্দিষ্টকালের জন্য রেখে গেছেন তা কেবল কৌতুহল।
জেসন

14
@ জেসন: দিবালোক সংরক্ষণই কেবলমাত্র আমি অফহ্যান্ডের কথা ভাবতে পারি - বেশিরভাগ অ্যাপ্লিকেশনের কাছে লিপ সেকেন্ডকে অপ্রাসঙ্গিক বলে উপেক্ষা করে। অন্যদের কেন এমন হতে পারে তা ভাবতে উত্সাহিত করার জন্য আমি বেশিরভাগই এটিকে রেখেছি। আমি মনে করি তাদের বর্তমানের চেয়ে তারিখ / সময় সম্পর্কে কিছুটা গভীরভাবে চিন্তা করা লোকের পক্ষে ভাল :) :)
জোন স্কিেট

লোকালটাইম হ'ল আমার প্রয়োজনটিকে সমর্থন করার জন্য।
sduplooy

1
@ এসডুপ্লয়: অভিনব আমাদের জোদা সময় থেকে এটি বন্দর সাহায্য? :)
জন স্কিটি

1
@ ওক্কুল: ঠিক যেমনটি আমি 18 ই মে বলেছি: Durationনোদা টাইমে, বা TimeSpanছাত্রলীগে। আমি সম্ভবত "ভিডিওতে + মন্তব্যে স্থান" টাইপ হিসাবে সজ্জিত করতে পারি এবং তারপরে সেই ধরণের একটি অ্যারে থাকি।
জন স্কিটি

164

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

TimeSpan timeSpan = new TimeSpan(2, 14, 18);
Console.WriteLine(timeSpan.ToString());     // Displays "02:14:18".

[সম্পাদনা]
অন্যান্য উত্তর এবং প্রশ্নের সম্পাদনা বিবেচনা করে আমি এখনও টাইমস্প্যান ব্যবহার করব। একটি নতুন কাঠামো তৈরি করার কোনও অর্থ নেই যেখানে ফ্রেমওয়ার্ক থেকে বিদ্যমান বিদ্যমান যথেষ্ট।
এই লাইনে আপনি অনেক নেটিভ ডেটা ধরণের অনুলিপি করতে পারেন।


19
যথাযথভাবে। ডেটটাইম ঠিক সেই উদ্দেশ্যে টাইমস্প্যান ব্যবহার করে। ডেটটাইম.টাইমস্প্যান বৈশিষ্ট্যের জন্য ডক: "এমন একটি টাইমস্প্যান যা মধ্যরাত থেকে অতিবাহিত হয়ে যাওয়া দিনের ভগ্নাংশকে উপস্থাপন করে।"
মার্সেল জ্যাকওয়ার্থ

4
টাইমস্প্যান একটি বিরতি নির্দেশ করে যেখানে আমি যে সময়টির কথা বলছি তা কোনও বিরতি নয়, বিভিন্ন তারিখের একক স্থির বিন্দু।
sduplooy

3
এটি পাশাপাশি একটি নির্দিষ্ট পয়েন্ট হিসাবে ব্যবহার করা যেতে পারে, এবং আপনি প্রশ্নে উল্লেখ করেছেন, এটি তারিখ ছাড়াই। সর্বোপরি আপনি কীভাবে আপনার বেনিফিটে এই ডেটাটাইপগুলি ব্যবহার করবেন তা স্থির করে নিন।
জন জি

9
@ জন জি: যদিও এটি একটি নির্দিষ্ট পয়েন্ট উপস্থাপন করতে ব্যবহার করা যেতে পারে, আমি ওপির সাথে একমত - TimeSpanএই জাতীয় ব্যবহারকে ওভারলোড করা কিছুটা কুৎসিত। এটি ফ্রেমওয়ার্কের মধ্যেই উপলব্ধ এটি সেরা, তবে এটি আনন্দদায়ক বলার মতো নয়।
জন স্কিটি

5
নেট নেট ৩.৫ হিসাবে, এমএসডিএন ডকুমেন্টস যে "টাইমস্প্যান কাঠামোটি দিনের সময়ের প্রতিনিধিত্ব করতে ব্যবহৃত হতে পারে তবে কেবল সময়টি কোনও নির্দিষ্ট তারিখের সাথে সম্পর্কিত না হলে"। অন্য কথায়, এটি হ'ল প্রস্তাবিত প্রশ্নের সমাধান।
ফারাপ

34

যদি Dateখালিটি আপনাকে সত্যিই বাগ দেয় তবে আপনি একটি সহজ Timeকাঠামো তৈরি করতেও পারেন :

// more work is required to make this even close to production ready
class Time
{
    // TODO: don't forget to add validation
    public int Hours   { get; set; }
    public int Minutes { get; set; }
    public int Seconds { get; set; }

    public override string ToString()
    {  
        return String.Format(
            "{0:00}:{1:00}:{2:00}",
            this.Hours, this.Minutes, this.Seconds);
    }
}

বা, কেন বিরক্ত করবেন: আপনার যদি সেই তথ্য দিয়ে কোনও গণনা করার দরকার না হয় তবে কেবল এটি হিসাবে সংরক্ষণ করুন String


2
হুমমম ... হতে পারে ... তবে চাকাটি নতুন করে কেন? যদি ভাষাটির ইতিমধ্যে কোনও শ্রেণি / কাঠামো থাকে (যা সি # এবং ভিবি.এনইটি করে) তবে এটির সাথে যান। তবে আপনি বুঝতে পেরেছেন কোথায় আপনি নিজের উত্তরটি দিয়ে যাচ্ছেন।
ক্রিস ক্রাউস

1
এই কাঠামোটি টাইমস্প্যানের থেকে আলাদা কীভাবে হবে, এটি কেবল এটি একরকম নকল করবে।
জন জি

4
এর অস্তিত্বের কারণে আপনাকে হ্রাস করা TimeSpan, যা ইতিমধ্যে এটি পরিচালনা করে এবং উল্লেখযোগ্যভাবে আরও ভাল উপায়ে।
দুপুর সিল্ক

1
@ সিলকি, আমি প্রথম উত্তরটি পড়ার পরে এটি লিখেছিলাম; ওপি প্রশ্নে বলেছিলেন যে তিনি টাইমস্প্যান ব্যবহার করতে চান না; আমি, ব্যক্তিগতভাবে, একটি সরল তারিখটাইম বেছে নেওয়ার পছন্দ করব
রুবেেন্স ফারিয়াস

18
+1 এটি টাইমস্প্যানের চেয়ে ভাল কারণ এতে ভুল ব্যাখ্যা করার কম সম্ভাবনা রয়েছে ... একটি টাইমস্প্যান আসলেই অন্তর্বর্তী হিসাবে ব্যবহৃত হয় (এমএসডিএন দেখুন) তাই টাইমস্প্যানকে সময় হিসাবে ব্যবহার করার সময় ডেসসের মতো সম্পত্তিটির কোনও অর্থ হয় না
জাইদ মাসুদ

20

আমি বলি একটি ডেটটাইম ব্যবহার করুন। আপনার যদি তারিখের অংশের প্রয়োজন না হয় তবে এটি এড়িয়ে যান। যদি আপনার ব্যবহারকারীর কাছে ঠিক সময় প্রদর্শনের দরকার হয় তবে এটির ব্যবহারকারীর কাছে এটির বিন্যাস করুন:

DateTime.Now.ToString("t");  // outputs 10:00 PM

দেখে মনে হচ্ছে একটি নতুন শ্রেণি তৈরি করা বা এমনকি টাইমস্প্যান ব্যবহারের সমস্ত অতিরিক্ত কাজ অপ্রয়োজনীয়।


আপনি এই পদ্ধতিতে সেকেন্ড এবং মিলি-সেকেন্ড কীভাবে দেখবেন?
মোনা জালাল

5
@MonaJalal মিলিসেকেন্ড: DateTime.Now.ToString("hh:mm:ss.fff");মাইক্রোসেকেন্ড: DateTime.Now.ToString("hh:mm:ss.ffffff");ন্যানোসেকেন্ড (DATETIME এমনকি যে অনেক রেজল্যুশন হয়েছে থাকে): DateTime.Now.ToString("hh:mm:ss.fffffffff");হিসাবে প্রতি দুটিই MSDN
Pharap

2
সুতরাং, এটির জন্য যথাযথ প্রকারটি প্রয়োগ করতে যে 5 থেকে 10 মিনিট সময় লাগে তা ভবিষ্যতের যে কোনও বিকাশের জন্য পুরো কোডবেজে বিবেচনা না করেই আপনার পক্ষে আরও বেশি কাজ মনে হয় যে ডেটটাইম সম্পত্তিটিতে কেবল একটি সময় থাকতে পারে এবং এটি ফর্ম্যাট করতে হবে এই পরিস্থিতিতে যেমন, এবং তারিখ অংশ উপেক্ষা করা প্রয়োজন হতে পারে? মজা ঘটনার ডিবাগ যেখানে আপনি পাবেন "0001-01-01 10:00" আপনার ডাটাবেসের মধ্যে, বাহ্যিক যোগাযোগ, ইত্যাদি অন্তর্ভুক্ত করুন ....
MarioDS

10

আমি মনে করি রুবেন্সের ক্লাসটি একটি ভাল ধারণা তাই মৌলিক বৈধতা সহ তার সময় শ্রেণীর একটি অবিচ্ছেদ্য নমুনা তৈরি করার কথা ভাবা হয়েছিল।

class Time
{
    public int Hours   { get; private set; }
    public int Minutes { get; private set; }
    public int Seconds { get; private set; }

    public Time(uint h, uint m, uint s)
    {
        if(h > 23 || m > 59 || s > 59)
        {
            throw new ArgumentException("Invalid time specified");
        }
        Hours = (int)h; Minutes = (int)m; Seconds = (int)s;
    }

    public Time(DateTime dt)
    {
        Hours = dt.Hour;
        Minutes = dt.Minute;
        Seconds = dt.Second;
    }

    public override string ToString()
    {  
        return String.Format(
            "{0:00}:{1:00}:{2:00}",
            this.Hours, this.Minutes, this.Seconds);
    }
}

আপনি যুক্ত বৈধতা অত্যন্ত গুরুত্বপূর্ণ। কোনও সময়ের মডেলিংয়ে টাইমস্প্যান ক্লাসের প্রধান ত্রুটিটি হ'ল দিনের সময়টি 24 ঘন্টাের বেশি হতে পারে।
19'র

কেন ঘন্টা, মিনিট এবং সেকেন্ড ব্যবহার করছেন এবং ইউএনটি নয়? যদি কোনও কারণ না থাকে তবে আমার মনে হয় তারা সরাসরি ইউন্ট ব্যবহার করতে পারে এবং এটি কনস্ট্রাক্টরের মধ্যে castালাই এড়ানো হয়।
শেলপাইপিয়ের

6

চিবুয়েজ ওপাটা ছাড়াও :

class Time
{
    public int Hours   { get; private set; }
    public int Minutes { get; private set; }
    public int Seconds { get; private set; }

    public Time(uint h, uint m, uint s)
    {
        if(h > 23 || m > 59 || s > 59)
        {
            throw new ArgumentException("Invalid time specified");
        }
        Hours = (int)h; Minutes = (int)m; Seconds = (int)s;
    }

    public Time(DateTime dt)
    {
        Hours = dt.Hour;
        Minutes = dt.Minute;
        Seconds = dt.Second;
    }

    public override string ToString()
    {  
        return String.Format(
            "{0:00}:{1:00}:{2:00}",
            this.Hours, this.Minutes, this.Seconds);
    }

    public void AddHours(uint h)
    {
        this.Hours += (int)h;
    }

    public void AddMinutes(uint m)
    {
        this.Minutes += (int)m;
        while(this.Minutes > 59)
            this.Minutes -= 60;
            this.AddHours(1);
    }

    public void AddSeconds(uint s)
    {
        this.Seconds += (int)s;
        while(this.Seconds > 59)
            this.Seconds -= 60;
            this.AddMinutes(1);
    }
}

আপনার মিনিট এবং সেকেন্ডের জন্য অ্যাড করার পদ্ধতিগুলি ভুল কারণ তারা 59
টিরও

@ শিবিউজ অপেট: আপনি পুরোপুরি ঠিক বলেছেন। এটি কেবল দ্রুত এবং নোংরা ছিল। আমার এই কোডটিতে আরও কিছু কাজ করা উচিত। আমি পরে এটি আপডেট করব ... আপনার ইঙ্গিত জন্য ধন্যবাদ!
জুলে

5

এখানে একটি সম্পূর্ণ বৈশিষ্ট্যযুক্ত টাইমঅফডে ক্লাস।

এটি সাধারণ কেসগুলির জন্য ওভারকিল, তবে আপনার মতো যদি আমার মতো আরও উন্নত কার্যকারিতা প্রয়োজন হয় তবে এটি সাহায্য করতে পারে।

এটি কোণার কেসগুলি, কিছু প্রাথমিক গণিত, তুলনা, ডেটটাইমের সাথে ইন্টারঅ্যাকশন, পার্সিং ইত্যাদি পরিচালনা করতে পারে

নীচে টাইমঅফডে ক্লাসের উত্স কোডটি রয়েছে। আপনি ব্যবহারের উদাহরণগুলি দেখতে এবং এখানে আরও শিখতে পারেন :

এই শ্রেণিটি তার বেশিরভাগ অভ্যন্তরীণ গণনা এবং তুলনাগুলির জন্য ডেটটাইম ব্যবহার করে যাতে আমরা ইতিমধ্যে ডেটটাইমে এম্বেড থাকা সমস্ত জ্ঞানের উপকার করতে পারি।

// Author: Steve Lautenschlager, CambiaResearch.com
// License: MIT

using System;
using System.Text.RegularExpressions;

namespace Cambia
{
    public class TimeOfDay
    {
        private const int MINUTES_PER_DAY = 60 * 24;
        private const int SECONDS_PER_DAY = SECONDS_PER_HOUR * 24;
        private const int SECONDS_PER_HOUR = 3600;
        private static Regex _TodRegex = new Regex(@"\d?\d:\d\d:\d\d|\d?\d:\d\d");

        public TimeOfDay()
        {
            Init(0, 0, 0);
        }
        public TimeOfDay(int hour, int minute, int second = 0)
        {
            Init(hour, minute, second);
        }
        public TimeOfDay(int hhmmss)
        {
            Init(hhmmss);
        }
        public TimeOfDay(DateTime dt)
        {
            Init(dt);
        }
        public TimeOfDay(TimeOfDay td)
        {
            Init(td.Hour, td.Minute, td.Second);
        }

        public int HHMMSS
        {
            get
            {
                return Hour * 10000 + Minute * 100 + Second;
            }
        }
        public int Hour { get; private set; }
        public int Minute { get; private set; }
        public int Second { get; private set; }
        public double TotalDays
        {
            get
            {
                return TotalSeconds / (24d * SECONDS_PER_HOUR);
            }
        }
        public double TotalHours
        {
            get
            {
                return TotalSeconds / (1d * SECONDS_PER_HOUR);
            }
        }
        public double TotalMinutes
        {
            get
            {
                return TotalSeconds / 60d;
            }
        }
        public int TotalSeconds
        {
            get
            {
                return Hour * 3600 + Minute * 60 + Second;
            }
        }
        public bool Equals(TimeOfDay other)
        {
            if (other == null) { return false; }
            return TotalSeconds == other.TotalSeconds;
        }
        public override bool Equals(object obj)
        {
            if (obj == null) { return false; }
            TimeOfDay td = obj as TimeOfDay;
            if (td == null) { return false; }
            else { return Equals(td); }
        }
        public override int GetHashCode()
        {
            return TotalSeconds;
        }
        public DateTime ToDateTime(DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day, Hour, Minute, Second);
        }
        public override string ToString()
        {
            return ToString("HH:mm:ss");
        }
        public string ToString(string format)
        {
            DateTime now = DateTime.Now;
            DateTime dt = new DateTime(now.Year, now.Month, now.Day, Hour, Minute, Second);
            return dt.ToString(format);
        }
        public TimeSpan ToTimeSpan()
        {
            return new TimeSpan(Hour, Minute, Second);
        }
        public DateTime ToToday()
        {
            var now = DateTime.Now;
            return new DateTime(now.Year, now.Month, now.Day, Hour, Minute, Second);
        }

        #region -- Static --
        public static TimeOfDay Midnight { get { return new TimeOfDay(0, 0, 0); } }
        public static TimeOfDay Noon { get { return new TimeOfDay(12, 0, 0); } }
        public static TimeOfDay operator -(TimeOfDay t1, TimeOfDay t2)
        {
            DateTime now = DateTime.Now;
            DateTime dt1 = new DateTime(now.Year, now.Month, now.Day, t1.Hour, t1.Minute, t1.Second);
            TimeSpan ts = new TimeSpan(t2.Hour, t2.Minute, t2.Second);
            DateTime dt2 = dt1 - ts;
            return new TimeOfDay(dt2);
        }
        public static bool operator !=(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else
            {
                return t1.TotalSeconds != t2.TotalSeconds;
            }
        }
        public static bool operator !=(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 != dt2;
        }
        public static bool operator !=(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 != dt2;
        }
        public static TimeOfDay operator +(TimeOfDay t1, TimeOfDay t2)
        {
            DateTime now = DateTime.Now;
            DateTime dt1 = new DateTime(now.Year, now.Month, now.Day, t1.Hour, t1.Minute, t1.Second);
            TimeSpan ts = new TimeSpan(t2.Hour, t2.Minute, t2.Second);
            DateTime dt2 = dt1 + ts;
            return new TimeOfDay(dt2);
        }
        public static bool operator <(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else
            {
                return t1.TotalSeconds < t2.TotalSeconds;
            }
        }
        public static bool operator <(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 < dt2;
        }
        public static bool operator <(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 < dt2;
        }
        public static bool operator <=(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else
            {
                if (t1 == t2) { return true; }
                return t1.TotalSeconds <= t2.TotalSeconds;
            }
        }
        public static bool operator <=(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 <= dt2;
        }
        public static bool operator <=(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 <= dt2;
        }
        public static bool operator ==(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else { return t1.Equals(t2); }
        }
        public static bool operator ==(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 == dt2;
        }
        public static bool operator ==(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 == dt2;
        }
        public static bool operator >(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else
            {
                return t1.TotalSeconds > t2.TotalSeconds;
            }
        }
        public static bool operator >(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 > dt2;
        }
        public static bool operator >(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 > dt2;
        }
        public static bool operator >=(TimeOfDay t1, TimeOfDay t2)
        {
            if (ReferenceEquals(t1, t2)) { return true; }
            else if (ReferenceEquals(t1, null)) { return true; }
            else
            {
                return t1.TotalSeconds >= t2.TotalSeconds;
            }
        }
        public static bool operator >=(TimeOfDay t1, DateTime dt2)
        {
            if (ReferenceEquals(t1, null)) { return false; }
            DateTime dt1 = new DateTime(dt2.Year, dt2.Month, dt2.Day, t1.Hour, t1.Minute, t1.Second);
            return dt1 >= dt2;
        }
        public static bool operator >=(DateTime dt1, TimeOfDay t2)
        {
            if (ReferenceEquals(t2, null)) { return false; }
            DateTime dt2 = new DateTime(dt1.Year, dt1.Month, dt1.Day, t2.Hour, t2.Minute, t2.Second);
            return dt1 >= dt2;
        }
        /// <summary>
        /// Input examples:
        /// 14:21:17            (2pm 21min 17sec)
        /// 02:15               (2am 15min 0sec)
        /// 2:15                (2am 15min 0sec)
        /// 2/1/2017 14:21      (2pm 21min 0sec)
        /// TimeOfDay=15:13:12  (3pm 13min 12sec)
        /// </summary>
        public static TimeOfDay Parse(string s)
        {
            // We will parse any section of the text that matches this
            // pattern: dd:dd or dd:dd:dd where the first doublet can
            // be one or two digits for the hour.  But minute and second
            // must be two digits.

            Match m = _TodRegex.Match(s);
            string text = m.Value;
            string[] fields = text.Split(':');
            if (fields.Length < 2) { throw new ArgumentException("No valid time of day pattern found in input text"); }
            int hour = Convert.ToInt32(fields[0]);
            int min = Convert.ToInt32(fields[1]);
            int sec = fields.Length > 2 ? Convert.ToInt32(fields[2]) : 0;

            return new TimeOfDay(hour, min, sec);
        }
        #endregion

        private void Init(int hour, int minute, int second)
        {
            if (hour < 0 || hour > 23) { throw new ArgumentException("Invalid hour, must be from 0 to 23."); }
            if (minute < 0 || minute > 59) { throw new ArgumentException("Invalid minute, must be from 0 to 59."); }
            if (second < 0 || second > 59) { throw new ArgumentException("Invalid second, must be from 0 to 59."); }
            Hour = hour;
            Minute = minute;
            Second = second;
        }
        private void Init(int hhmmss)
        {
            int hour = hhmmss / 10000;
            int min = (hhmmss - hour * 10000) / 100;
            int sec = (hhmmss - hour * 10000 - min * 100);
            Init(hour, min, sec);
        }
        private void Init(DateTime dt)
        {
            Init(dt.Hour, dt.Minute, dt.Second);
        }
    }
}

2

আপনি যদি কোনও ডেটটাইম বা টাইমস্প্যান ব্যবহার করতে না চান এবং কেবল দিনের সময় সংরক্ষণ করতে চান তবে আপনি মধ্যরাত থেকে একটি ইন্টার 32 তে সেকেন্ড সংরক্ষণ করতে পারেন, বা (আপনি যদি সেকেন্ডও চান না) মধ্যরাত থেকে কয়েক মিনিট পরে একটি int16 মধ্যে ফিট হবে। এই জাতীয় মান থেকে আওয়ার, মিনিট এবং দ্বিতীয় অ্যাক্সেসের জন্য প্রয়োজনীয় কয়েকটি পদ্ধতি লিখতে হবে তুচ্ছ।

তারিখটাইম / টাইমস্প্যান এড়াতে আমি কেবল কারণটি মনে করতে পারি যদি কাঠামোর আকার সমালোচনা হয়।

(অবশ্যই, আপনি যদি ক্লাসে জড়িত উপরের মতো একটি সাধারণ স্কিম ব্যবহার করেন, তবে আপনি যদি হঠাৎ করে বুঝতে পারেন যে এটি আপনাকে কোনও সুবিধা দেবে তবে ভবিষ্যতে টাইমস্প্যান দিয়ে স্টোরেজটি প্রতিস্থাপন করাও ক্ষুদ্র হবে)

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.