क्या .NET में "रेंज" का प्रतिनिधित्व करने के लिए एक मानक वर्ग है?

Question

हमारे पास बहुत सारे कोड हैं जिनमें कीमतों, लाभ, लागत इत्यादि जैसी चीजों के लिए "न्यूनतम" और "अधिकतम" मान हैं। वर्तमान में इन्हें विधियों के लिए दो पैरामीटर के रूप में पारित किया जाता है और अक्सर उन्हें पुनर्प्राप्त करने के लिए अलग-अलग गुण/विधियां होती हैं।

मैंने पिछले कुछ दशकों में विभिन्न कोड अड्डों में मूल्यों की श्रेणियों को स्टोर करने के लिए 101 कस्टम कक्षाएं देखी हैं, इससे पहले कि मैं एक और ऐसी कक्षा बनाऊं, मैं यह पुष्टि करना चाहता हूं कि इन दिनों .NET ढांचे में ऐसा नहीं है एक वर्ग कहीं में बनाया गया।

(मैं जानता हूँ कि अगर जरूरत अपने ही वर्ग बनाने का तरीका है, लेकिन हम इस दुनिया में भी कई पहियों मुझे सिर्फ एक लहर परागकोष एक आविष्कार करने के लिए पहले से ही के लिए)

Answer 1

यह सही है, वहाँ कोई निर्माण किया है श्रेणी में सी # या बीसीएल में कक्षा में। हालांकि, समय अवधि का प्रतिनिधित्व करने के लिए बीसीएल में TimeSpan है, जिसे आप कई बार प्रतिनिधित्व करने के लिए DateTime के साथ अतिरिक्त रूप से लिख सकते हैं।

Answer 2

AFAIK .NET में ऐसी कोई चीज़ नहीं है। यद्यपि एक सामान्य कार्यान्वयन के साथ आने के लिए दिलचस्प होगा।

एक सामान्य बीसीएल गुणवत्ता रेंज प्रकार का निर्माण बहुत काम है, लेकिन यह कुछ इस तरह दिख सकता है:

public enum RangeBoundaryType 
{ 
    Inclusive = 0, 
    Exclusive 
} 

public struct Range<T> : IComparable<Range<T>>, IEquatable<Range<T>> 
    where T : struct, IComparable<T> 
{ 
    public Range(T min, T max) : 
     this(min, RangeBoundaryType.Inclusive, 
      max, RangeBoundaryType.Inclusive) 
    { 
    } 

    public Range(T min, RangeBoundaryType minBoundary, 
     T max, RangeBoundaryType maxBoundary) 
    { 
     this.Min = min; 
     this.Max = max; 
     this.MinBoundary = minBoundary; 
     this.MaxBoundary = maxBoundary; 
    } 

    public T Min { get; private set; } 
    public T Max { get; private set; } 
    public RangeBoundaryType MinBoundary { get; private set; } 
    public RangeBoundaryType MaxBoundary { get; private set; } 

    public bool Contains(Range<T> other) 
    { 
     // TODO 
    } 

    public bool OverlapsWith(Range<T> other) 
    { 
     // TODO 
    } 

    public override string ToString() 
    { 
     return string.Format("Min: {0} {1}, Max: {2} {3}", 
      this.Min, this.MinBoundary, this.Max, this.MaxBoundary); 
    } 

    public override int GetHashCode() 
    { 
     return this.Min.GetHashCode() << 256^this.Max.GetHashCode(); 
    } 

    public bool Equals(Range<T> other) 
    { 
     return 
      this.Min.CompareTo(other.Min) == 0 && 
      this.Max.CompareTo(other.Max) == 0 && 
      this.MinBoundary == other.MinBoundary && 
      this.MaxBoundary == other.MaxBoundary; 
    } 

    public static bool operator ==(Range<T> left, Range<T> right) 
    { 
     return left.Equals(right); 
    } 

    public static bool operator !=(Range<T> left, Range<T> right) 
    { 
     return !left.Equals(right); 
    } 

    public int CompareTo(Range<T> other) 
    { 
     if (this.Min.CompareTo(other.Min) != 0) 
     { 
      return this.Min.CompareTo(other.Min); 
     } 

     if (this.Max.CompareTo(other.Max) != 0) 
     { 
      this.Max.CompareTo(other.Max); 
     } 

     if (this.MinBoundary != other.MinBoundary) 
     { 
      return this.MinBoundary.CompareTo(other.Min); 
     } 

     if (this.MaxBoundary != other.MaxBoundary) 
     { 
      return this.MaxBoundary.CompareTo(other.MaxBoundary); 
     } 

     return 0; 
    } 
} 

Answer 3

मैं अपने खुद के बनाने के लिए शुरू कर दिया है।

public class Range<T> where T : IComparable 
{ 
    private readonly T start; 

    private readonly T end; 

    public Range(T start, T end) 
    { 
     if (start.CompareTo(end) < 0) 
     { 
      this.start = start; 
      this.end = end; 
     } 
     else 
     { 
      this.start = end; 
      this.end = start; 
     } 
    } 

    public T Start 
    { 
     get 
     { 
      return this.start; 
     } 
    } 

    public T End 
    { 
     get 
     { 
      return this.end; 
     } 
    } 

    public static bool Intersect(Range<T> a, Range<T> b) 
    { 
     return !(b.Start.CompareTo(a.End) > 0 || a.Start.CompareTo(b.End) > 0); 
    } 

    public bool Intersect(Range<T> other) 
    { 
     return Intersect(this, other); 
    } 
}