C# 在具有相同基类的两个数据类型之间创建扩展间方法检查值

我有一个变量，其值在运行时填充。我想检查该值是否在两个不同的数据类型值（比如最低值和最高值）之间，或者是否使用扩展方法

这两个值（最低值和最高值）可以是相同的数据类型（没有问题）。那就好像

public static bool Between<T>(this T actual, T lower, T upper) 
    where T : IComparable<T>
{
    return actual.CompareTo(lower) >= 0 && actual.CompareTo(upper) <= 0;
}

在上面的代码片段中，我正在检查int值和double值之间的字节值。在这种情况下怎么办。我想创建一个扩展方法，如

public static bool Between<T1, T2, T3>(this T1 actual, T2 lowest, T3 highest) 
     where T1: ???? 
     where T2: ????
     where T3: ????
{
     What code to write here???? 
}

public static bool-Between（T1实际值、T2最低值、T3最高值）
式中T1:？？？？
其中T2:？？？？
其中T3:？？？？
{
在这里写什么代码？？？？
}

---

对于上面的代码片段，my EM应该返回

true

如果您对数值类型进行操作，这些类型是CLR中的一级公民，那么您自然不能对它们应用契约/接口。我想到的是，将它们全部转换为更大的通用数字类型，然后进行比较，比如（伪代码）：

使用后，您可以像这样：

if(a.Between(0,(decimal)8.0))

public static bool-Between（T1实际值、T2最低值、T3最高值）
其中T1:T，i可比较
式中T2:T
其中T3:T>
{
返回actual.CompareTo（lower）>=0&&actual.CompareTo（upper）
IComparable要求被比较的
类型与被比较的
类型相同
类型。因此，您需要具有与
actual
相同的
类型、最低的
和最高的
类型

这意味着要做这样的事情：

byte a = 2;
decimal toCompare = (decimal)a;

if(toCompare.Between(0.0, 8.0))
{
   DoSomething();
}
else
{
   DoNothing();
}

如果尝试跨类型进行比较，则在运行时会出现异常

Console.WriteLine(1.CompareTo(2.0));

将导致抛出异常，并显示消息“对象必须为Int32类型”。
没有那么优雅，但我会使用特定的方法进行数值比较

 public static bool BetweenNumeric<T1, T2, T3>(this T1 actual, T2 lowest, T3 highest)
            where T1 : IConvertible
            where T2 : IConvertible
            where T3 : IConvertible
        {
            try
            {
                var actualDouble = Convert.ToDouble(actual);
                var lowestDouble = Convert.ToDouble(lowest);
                var highestDouble = Convert.ToDouble(highest);
                return (actualDouble).CompareTo(lowestDouble) >= 0 && actualDouble.CompareTo(highestDouble) <= 0;
            }
            catch
            {
                return false;
            }
        }

数字之间的公共静态布尔值（T1实际值，T2最低值，T3最高值）
其中T1:IConvertible
其中T2:i可转换
其中T3:i可转换
{
尝试
{
var actualDouble=Convert.ToDouble（实际值）；
var lowestDouble=Convert.ToDouble（最低）；
var highestDouble=Convert.ToDouble（最高）；
return（actualDouble）.CompareTo（lowerstdouble）>=0&&actualDouble.CompareTo（highestDouble）刚刚尝试过，我得到的最接近的结果是：

public static bool Between<T1, T2, T3>(this T1 actual, T2 lowest, T3 highest) 
     where T1: IComparable 
     where T2: IConvertible
     where T3: IConvertible
{
     return actual.CompareTo(lowest.ToType(typeof(T1), null)) >= 0 && 
            actual.CompareTo(highest.ToType(typeof(T1), null)) <= 0;
}

public static bool-Between（T1实际值、T2最低值、T3最高值）
其中T1:i可比较
其中T2:i可转换
其中T3:i可转换
{
返回实际的.CompareTo（最低的.ToType（typeof（T1），null））>=0&&
实际的.CompareTo（最高的.ToType（typeof（T1），null））你试过了吗？T是从哪里来的？你知道它有什么可比性吗？谢谢你的指点，我错过了这一点，并且只关注了问题中的基派生类型。如果你在约束中使用T，它必须出现在声明中。我想你错过了EM。如果这是我想做的，为什么它会写Ext.-Met.等等关于我将如何继续转换每个可用的数据类型。我认为你错过了EM点。如果这是我想要做的，为什么它会写Ext.-Met。更多的是关于我将如何继续转换每个可用的数据类型。当
T1
是
byte
，
T时，写出你希望在示例中执行的可编译代码2 是<代码> int ，等等。看看这个代码，并考虑有什么希望使它成为通用的。如果扩展方法没有拼写<代码> > <代码> >在我的眼中听起来更好。@ Felixk：它的扩展代码方法在我的大脑中听起来更好。你的例子没有显示“不同的数据类型，但相同的基类”。很难回答一个问题，当它自相矛盾的时候，认真地写一个方法<代码> < <代码> >静态类型，因为它需要存在，以满足你的例子：<代码>字节，<代码> int ，<代码>双< /代码>。把它写出来。然后考虑你编写的方法可能是通用的。
Console.WriteLine(1.CompareTo(2.0));

 public static bool BetweenNumeric<T1, T2, T3>(this T1 actual, T2 lowest, T3 highest)
            where T1 : IConvertible
            where T2 : IConvertible
            where T3 : IConvertible
        {
            try
            {
                var actualDouble = Convert.ToDouble(actual);
                var lowestDouble = Convert.ToDouble(lowest);
                var highestDouble = Convert.ToDouble(highest);
                return (actualDouble).CompareTo(lowestDouble) >= 0 && actualDouble.CompareTo(highestDouble) <= 0;
            }
            catch
            {
                return false;
            }
        }

public static bool Between<T1, T2, T3>(this T1 actual, T2 lowest, T3 highest) 
     where T1: IComparable 
     where T2: IConvertible
     where T3: IConvertible
{
     return actual.CompareTo(lowest.ToType(typeof(T1), null)) >= 0 && 
            actual.CompareTo(highest.ToType(typeof(T1), null)) <= 0;
}