वर्षों के लिए पैरामीटर प्रकार

Question

मैं एक विधि लिख रहा हूं जो वर्ष को पैरामीटर के रूप में स्वीकार करता है। अर्थात। चार अंकों की संख्या वर्तमान वर्ष की तुलना में बराबर या कम है। कैलेंडर केवल ग्रेगोरियन है (अभी के लिए .. भविष्य के बारे में निश्चित नहीं है) और मुझे निश्चित रूप से बीसी की आवश्यकता नहीं होगी।

मैं किस डेटा प्रकार का उपयोग करने के लिए उपयोग कर रहा हूँ? स्पष्ट समाधान दिनांक समय या Int32 का उपयोग करेंगे:

public void MyFunction(DateTime date) 
{ 
    // year to work with: date.Year; 
    // date.Month, date.Day, etc. is irrelevant and will always be 
} 

या

public void MyFunction(Int year) 
{ 
    if (year > 9999 || otherValidations == false) 
    { 
     //throw new Exception... 
    } 

    // year to work with: new DateTime(year, 1, 1); 
} 

मेरे स्वयं के कस्टम डेटा प्रकार वर्ष लेखन से अलग किसी भी अन्य विकल्प?

Answer 1

एक int ज्यादातर मामलों में ठीक काम करेगा।

क्या DateTime.Year है और वह है क्या DateTime निर्माता में लगता है, इसलिए जब तक आप एक और डेटा प्रकार की आवश्यकता होगी, के लिए एक विशेष कारण है है यही कारण है, एक पूर्णांक शायद के साथ काम करने के लिए सबसे आसान बात है।

Answer 2

आप एक अपरिवर्तनीय struct में लपेट कर सकता है लेकिन मूल रूप से यह कुछ बाधाओं के साथ एक int है।

Answer 3

मैं कहूंगा: DateTime के लिए जाएं क्योंकि आपके पास पहले से ही ऑपरेशन परिभाषित हैं कि आपको आवश्यकता हो सकती है। पहिया को फिर से क्यों शुरू करें?

Answer 4

शायद int। एक संपूर्ण डेटटाइम ऑब्जेक्ट को स्वीकार करना भ्रमित होगा, क्योंकि आपकी विधि को केवल वर्ष की आवश्यकता है। वहां से, int तार्किक पसंद है क्योंकि यह डेटटाइम का प्रकार है। प्रिय संपत्ति।

Answer 5

एक कस्टम डेटा प्रकार Year लिखें। SO :-) पर पूछने से यह तेज़ है: int का उपयोग करते समय आप समान व्यवहार प्राप्त करने के लिए इसे struct के रूप में घोषित कर सकते हैं लेकिन प्रकार के तर्क में अपनी विशिष्ट बाधा डाल सकते हैं।

Answer 6

यह इस बात पर निर्भर करता है कि आप साल के साथ क्या करने की योजना बना रहे हैं। यदि आप इसे बहुत से पास करने की योजना बना रहे हैं, तो अपने कस्टम struct को एक इंटैप्सूल करने का एक अच्छा विचार हो सकता है, क्योंकि आपको एक ही संख्या को कई बार मान्य करने की आवश्यकता नहीं होगी। अन्यथा, एक सादा पुराना int ठीक काम करेगा।

Answer 7

वर्ष int है। लेकिन अगर आप इसे संपत्ति में बदल सकते हैं, तो आप सेट में कुछ सत्यापन जोड़ सकते हैं, भले ही कुछ फ़ंक्शन में इनपुट केवल आप इसे सत्यापित करने के लिए नया फ़ंक्शन जोड़ सकें।

int year; 
public int Year 
{ 
    get 
    { 
     if (year > 9999) 
      throw ... 
     // check other constrains ... 
     return year; 
    } 
    set 
    { 
     if (value > 9999) 
     throw ... 
     // check other constrains ... 

     year = value; 
    } 
} 

एक समारोह के रूप में:

int GetYear(int year) 
{ 
    do validation and possibly throw an exception 
    return year; 
} 

लेकिन यदि आप इसे सिर्फ एक समारोह में उपयोग उनमें से किसी को ऐसा करने के लिए, जिम्मेदार समारोह में अपने सत्यापन करना कोई जरूरत नहीं है।

Answer 8

मैं तब तक int का उपयोग करूंगा जब तक कि आप बीसी या गैर-ग्रेगोरियन वर्षों से निपटने की योजना नहीं बनाते (उनके बीच रूपांतरण के साथ)। बीसी मामले में, आप ToString के माध्यम से प्रदर्शन उद्देश्यों के लिए एक साल की संरचना चाहते हैं। गैर-ग्रेगोरियन मामले में, चीजें अधिक जटिल हो जाती हैं।

Answer 9

जबकि यह एक int उपयोग करने के लिए संभव है, लेकिन क्योंकि यह व्यक्त करता है सबसे अच्छा तरीका है, एक विशेष struct लागू करने के लिए है अपने बेहतर इरादा:

public struct Year : IEquatable<Year>, IEquatable<DateTime>, IEquatable<int> 
{ 
    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="year"></param> 
    /// <exception cref="ArgumentOutOfRangeException"> 
    ///  When <see cref="year"/> is not within the range from <value>1</value> to <value>9999</value>. 
    /// </exception> 
    public Year(int year) 
    { 
     // same limits as DateTime 
     // be careful when changing this values, because it might break 
     // conversion from and to DateTime 
     var min = 1; 
     var max = 9999; 

     if (year < min || year > max) 
     { 
      var message = string.Format("Year must be between {0} and {1}.", min, max); 
      throw new ArgumentOutOfRangeException("year", year, message); 
     } 

     _value = year; 
    } 

    private readonly int _value; 

    public bool Equals(Year other) 
    { 
     return _value == other._value; 
    } 

    public bool Equals(DateTime other) 
    { 
     return _value == other.Year; 
    } 

    public bool Equals(int other) 
    { 
     return _value == other; 
    } 

    public override bool Equals(object obj) 
    { 
     if (ReferenceEquals(null, obj)) 
     { 
      return false; 
     } 

     if (obj is Year) return Equals((Year) obj); 
     if (obj is int) return Equals((int)obj); 
     if (obj is DateTime) return Equals((DateTime) obj); 
     return false; 
    } 

    public static Year MinValue 
    { 
     get 
     { 
      return new Year(DateTime.MinValue.Year); 
     } 
    } 

    public static Year MaxValue 
    { 
     get 
     { 
      return new Year(DateTime.MaxValue.Year); 
     } 
    } 

    public override int GetHashCode() 
    { 
     return _value; 
    } 

    public static bool operator ==(Year left, Year right) 
    { 
     return left.Equals(right); 
    } 

    public static bool operator !=(Year left, Year right) 
    { 
     return !left.Equals(right); 
    } 

    public override string ToString() 
    { 
     return _value.ToString(); 
    } 

    public string ToString(IFormatProvider formatProvider) 
    { 
     return _value.ToString(formatProvider); 
    } 

    public string ToString(string format) 
    { 
     return _value.ToString(format); 
    } 

    public string ToString(string format, IFormatProvider formatProvider) 
    { 
     return _value.ToString(format, formatProvider); 
    } 

    public DateTime ToDateTime() 
    { 
     return new DateTime(_value, 1, 1); 
    } 

    public int ToInt() 
    { 
     return _value; 
    } 

    public static implicit operator DateTime(Year year) 
    { 
     return new DateTime(year._value, 1, 1); 
    } 

    public static explicit operator Year(DateTime dateTime) 
    { 
     return new Year(dateTime.Year); 
    } 

    public static explicit operator int(Year year) 
    { 
     return year._value; 
    } 

    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="year"></param> 
    /// <returns></returns> 
    /// <exception cref="ArgumentOutOfRangeException"> 
    ///  When <see cref="year"/> is not within the range from <value>1</value> to <value>9999</value>. 
    /// </exception> 
    public static explicit operator Year(int year) 
    { 
     return new Year(year); 
    } 
}