c# - 这个(通用范围类)条件逻辑应该用多态性代替吗？如果是，那为什么？

Question

下面显示的是一个通用范围类。这样做的目的是保存一个范围，然后在请求时指定( bool 值)给定值是否在范围内。

我已阅读多篇文章、问题、博客等内容为“Replace Conditional with Polymorphism”

我的问题是，是否真的值得将代码分成多个类，每个类实际上只有一行代码。希望下面的代码能说明我的意思。

该类依赖于另外两个类，此处未显示，但如果有人需要，我可以稍后包含它。

namespace Common.Utilities
{
    public class GenericRange<T>
       where T : struct, IComparable<T>
   {
      #region Properties
      public T Min { get; private set; }
      public T Max { get; private set; }
      public GenericRangeType RangeType { get; private set; }
      #endregion

      #region Constructors
      public GenericRange(T min, T max, GenericRangeType rangeType = GenericRangeType.Inclusive)
      {
         // Check Parameters
         Min = min;
         Max = max;
         RangeType = rangeType;
      }
      #endregion

      #region Methods
      #region Private
      private bool IsInclusive(T value)
      {
         return value.IsGreaterThanOrEqualTo(Min) && value.IsLessThanOrEqualTo(Max);
      }

      private bool IsInclusiveMin(T value)
      {
         return value.IsGreaterThanOrEqualTo(Min) && value.IsLessThan(Max);
      }

      private bool IsInclusiveMax(T value)
      {
         return value.IsGreaterThan(Min) && value.IsLessThanOrEqualTo(Max);
      }

      private bool IsExclusive(T value)
      {
         return value.IsGreaterThan(Min) && value.IsLessThan(Max);
      }
      #endregion

      #region Public
      public bool Contains(T value)
      {
         switch (RangeType)
         {
            case GenericRangeType.Inclusive: return IsInclusive(value);
            case GenericRangeType.InclusiveMin: return IsInclusiveMin(value);
            case GenericRangeType.InclusiveMax: return IsInclusiveMax(value);
            case GenericRangeType.Exclusive: return IsExclusive(value);
            default: throw new NotImplementedException();
         }
      }

      public override string ToString()
      {
         return String.Format("Min: {0}, Max: {1}, Type: {2}", Min, Max, RangeType);
      }
      #endregion
      #endregion
    }
}

唯一的公共(public)方法是:Contain 和 ToString。 如果我通过多态性正确理解它，我应该为每个比较类型创建一个单独的具体类，然后使 Contain 成为一个虚拟方法。

我想了解的主要是，好处/优势是什么？

如果这是这个问题的错误地方，那么我很抱歉。让我知道，我会移动它。

编辑 1: 如果有人需要，可以完成此操作的附加代码:

public static class ComparableExtensions
{
    public static bool IsEqualTo<T>(this T leftHand, T value) where T : IComparable<T>
    {
        return leftHand.CompareTo(value) == 0;
   }

    public static bool IsGreaterThan<T>(this T leftHand, T value) where T : IComparable<T>
    {
        return leftHand.CompareTo(value) > 0;
    }
    public static bool IsGreaterThanOrEqualTo<T>(this T leftHand, T value) where T : IComparable<T>
    {
        return leftHand.CompareTo(value) >= 0;
    }

    public static bool IsLessThan<T>(this T leftHand, T value) where T : IComparable<T>
    {
        return leftHand.CompareTo(value) < 0;
    }
    public static bool IsLessThanOrEqualTo<T>(this T leftHand, T value) where T : IComparable<T>
    {
        return leftHand.CompareTo(value) <= 0;
    }
}   

public enum GenericRangeType
{
    Inclusive,
    Exclusive,
    InclusiveMin,
    InclusiveMax
}

Answer 1

将其分解为不同的类可以让您在不更改现有代码的情况下扩展 Contains。在这种情况下，它并没有多大意义，因为您已经在此处涵盖了 contains 的所有基础，但在其他情况下，可扩展性可能非常有用。