C# 这个（泛型范围类）条件逻辑应该被多态性取代吗？如果是，为什么？

下面显示的是泛型范围类。这样做的目的是保存一个范围，然后在请求时指定（布尔）给定值是否在该范围内

我读过多篇帖子、问题、博客等，上面写着“”

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

这个类依赖于另外两个类，这里没有显示，但是如果有人需要它，我可以在以后包含它

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

namespace-Common.Utilities
{
公共类通用范围
其中T:struct，i可比较
{
#区域属性
公共T Min{get；私有集；}
公共T Max{get；私有集；}
公共GenericRangeType RangeType{get；private set；}
#端区
#区域构造函数
公共GenericRange（T最小值、T最大值、GenericRangeType范围类型=GenericRangeType.Inclusive）
{
//检查参数
Min=Min；
Max=Max；
RangeType=RangeType；
}
#端区
#区域方法
#地区私人
私有布尔值（T值）
{
返回值大于或等于零（最小值）和小于或等于零（最大值）；
}
私有布尔值（T值）
{
返回值大于或等于最小值&小于最大值；
}
私有布尔IsInclusiveMax（T值）
{
返回值大于（最小值）和值小于或等于（最大值）；
}
私有布尔值为独占（T值）
{
返回值大于（最小值）和小于（最大值）的值；
}
#端区
#地区公众
公共布尔包含（T值）
{
开关（量程型）
{
大小写GenericRangeType.Inclusive：返回IsInclusive（值）；
case-generichangeType.InclusiveMin：返回IsInclusiveMin（值）；
case-generiRangeType.InclusiveMax：返回IsInclusiveMax（值）；
大小写GenericRangeType.Exclusive：返回IsExclusive（值）；
默认值：抛出新的NotImplementedException（）；
}
}
公共重写字符串ToString（）
{
返回String.Format（“Min:{0}，Max:{1}，Type:{2}”，Min，Max，RangeType）；
}
#端区
#端区
}
}

唯一的公共方法是：Contain和ToString。 如果我通过多态性正确地理解了它，我应该为每个comparison类型创建一个单独的具体类，然后让它包含一个虚拟方法

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

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

编辑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
}

公共静态类CompariableExtensions
{
公共静态布尔IsEqualTo（T左手，T值），其中T:i可比较
{
返回leftHand.CompareTo（值）==0；
}
公共静态布尔大于（T左手，T值），其中T:i可比较
{
返回leftHand.CompareTo（值）>0；
}
公共静态布尔值大于或等于（T左手，T值），其中T:i可比较
{
返回leftHand.CompareTo（值）>=0；
}
公共静态布尔值小于（T左手，T值），其中T:i可比较
{
返回leftHand.CompareTo（值）<0；
}
公共静态布尔值小于或等于（T左手，T值），其中T:i可比较
{
返回leftHand.CompareTo（value）将其拆分为不同的类，可以在不更改现有代码的情况下扩展包含。在这种情况下，它没有太大意义，因为您已经在这里介绍了包含的所有基础，但在其他情况下，可扩展性可能非常有用。
IMO-您使用了泛型，这更像是一个“模板”类，而不是经典OOPS术语中纯粹的基类

我的意思是，如果你写过这样的课程：

public class GenericRange{...}

public class IntRange : GenericRange{...}
public class DecimalRange : GenericRange{...}

在这种情况下，将Contains的实现分解为单独的子类型作为重写方法是有意义的

但是，由于您使用的是代码模板，因此您确实可以获得多态行为的好处，这取决于您初始化模板类的方式

所以，如果你这样做了：

new GenericRange<int>(1, 100, inclusive);
new GenericRange<decimal>(1.0, 100.0, inclusive);

新的通用范围（1100个，含1100个）；
新的通用范围（1.0、100.0，包括在内）；

您已经完成了多态行为，我认为这是泛型的一大好处，因为它允许您对此类代码进行模板化，而不是像前面所示的那样拥有专门的子类。
我认为您所拥有的是好的，只要它在将来不需要太多扩展，并且您不需要将其作为一个公共类，而c可以在其他程序集中扩展。如果您想要更大的灵活性，可以使用多态性，或者创建一个
Func
（可能是
private
，因为您可能只想公开
包含的
方法，而不是它是使用
Func
实现的）当设置了
RangeType
时会设置它。然后您的
Contains
方法变为
return myFunc（值）；
我不太懂Func、匿名、表达式、委托。这或多或少是在声明委托。我开始声明委托，但后来没有看到什么好处。你能用Func的一个小示例给我一个更好的解释吗