Có một lớp tiêu chuẩn để đại diện cho một "phạm vi" trong .net?

Question

Chúng ta có rất nhiều mã có giá trị “min” và “max” cho những thứ như giá cả, lợi nhuận, chi phí… Hiện tại chúng được chuyển thành hai tham số cho phương thức và thường có các thuộc tính/phương thức khác nhau để lấy chúng.

Tôi đã thấy 101 lớp tùy chỉnh để lưu trữ dãy giá trị trong các cơ sở mã khác nhau trong vài thập kỷ qua, trước khi tôi tạo một lớp khác như vậy, tôi muốn xác nhận rằng khung .NET. một lớp được xây dựng trong ở đâu đó.

(Tôi biết làm thế nào để tạo ra lớp của riêng tôi, nếu cần thiết, nhưng chúng tôi có quá nhiều bánh xe trong thế giới này đã cho tôi để chỉ phát minh ra bao phấn một trên một ý thích)

Answer 1

Đó là đúng, không có xây dựng -in lớp trong C# hoặc BCL cho các phạm vi. Tuy nhiên, có TimeSpan trong BCL để đại diện cho các khoảng thời gian mà bạn có thể soạn thêm với một số DateTime để biểu thị một loạt thời gian.

Answer 2

AFAIK không có điều nào trong .NET. Sẽ là thú vị mặc dù, để đến với một thực hiện chung chung.

Xây dựng BCL loại phạm vi chất lượng chung là rất nhiều công việc, nhưng nó có thể trông giống như thế này:

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

Tôi đã bắt đầu để làm của riêng tôi.

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