C# switch语句中使用相同别名的多个事例

我想知道是否有人对如何组合我的开关的两种情况有意见，这两种情况几乎相同，但一种是针对可空值的，另一种不是

        switch (rangeA)
        {
            case Range<int> intRangeA:
            {
                if (rangeB is Range<int> intRangeB)
                {
                    return intRangeA.ValueFrom <= intRangeB.ValueTo && intRangeA.ValueTo >= intRangeB.ValueFrom;
                }

                return false;
            }

            case Range<int?> intRangeA:
            {
                if (rangeB is Range<int?> intRangeB)
                {
                    return intRangeA.ValueFrom <= intRangeB.ValueTo && intRangeA.ValueTo >= intRangeB.ValueFrom;
                }

                return false;
            }
        }

开关（范围A）
{
在GEA内的案例范围：
{
如果（范围B是范围B）
{
返回intRangeA.ValueFrom=intRangeB.ValueFrom；
}
返回false；
}
在GEA内的案例范围：
{
如果（范围B是范围B）
{
返回intRangeA.ValueFrom=intRangeB.ValueFrom；
}
返回false；
}
}

这取决于

rangeA

和

rangeB

的数据类型

假设它们是

对象

，您可以这样做。如果您创建一个

范围

，然后对其调用

ContainsInclusive，它将在运行时引发异常。如果需要，可以添加额外的检查，但它会变得有点混乱，因为
Nullable
没有实现任何接口，所以必须求助于反射

public class Program
{
    public static void Main()
    {
        Foo(new Range<int>() { ValueFrom = 1, ValueTo = 10 }, new Range<int>() { ValueFrom = 0, ValueTo = 10 });
        Foo(new Range<int?>() { ValueFrom = 1, ValueTo = 10 }, new Range<int?>() { ValueFrom = 0, ValueTo = 10 });
    }
    
    private static bool Foo(object rangeA, object rangeB)
    {
        return (rangeA, rangeB) switch
        {
            (Range<int> a, Range<int> b) => b.ContainsInclusive(a),
            (Range<int?> a, Range<int?> b) => b.ContainsInclusive(a),
            _ => false,
        };
    }
}

public class Range<T> 
{
    public T ValueFrom { get; set; }
    public T ValueTo { get; set; }
    
    public bool ContainsInclusive(Range<T> other)
    {
        return Comparer<T>.Default.Compare(other.ValueFrom, this.ValueTo) <= 0 &&
            Comparer<T>.Default.Compare(other.ValueTo, this.ValueFrom) >= 0; 
    }
}


如果
rangeA
和
rangeB
可以是某个基本
Range
类型，那么您可以这样做。同样，如果
T
不可比较，则在运行时会抛出：

public class Program
{
    public static void Main()
    {
        Foo(new Range<int>() { ValueFrom = 1, ValueTo = 10 }, new Range<int>() { ValueFrom = 0, ValueTo = 10 }).Dump();
        Foo(new Range<int?>() { ValueFrom = 1, ValueTo = 10 }, new Range<int?>() { ValueFrom = 0, ValueTo = 10 }).Dump();
    }
    
    private static bool Foo(Range rangeA, Range rangeB)
    {
        return rangeB.ContainsInclusive(rangeA);
    }
}

public abstract class Range
{
    public abstract bool ContainsInclusive(Range other);
}

public class Range<T> : Range
{
    public T ValueFrom { get; set; }
    public T ValueTo { get; set; }
    
    public override bool ContainsInclusive(Range other)
    {
        if (other is Range<T> o)
        {
            return Comparer<T>.Default.Compare(o.ValueFrom, this.ValueTo) <= 0 &&
                Comparer<T>.Default.Compare(o.ValueTo, this.ValueFrom) >= 0;    
        }
        
        return false;
    }
}

公共类程序
{
公共静态void Main（）
{
Foo（新范围（）{ValueFrom=1，ValueTo=10}，新范围（）{ValueFrom=0，ValueTo=10}）；
Foo（新范围（）{ValueFrom=1，ValueTo=10}，新范围（）{ValueFrom=0，ValueTo=10}）；
}
专用静态bool Foo（范围A、范围B）
{
返回范围B.ContainsInclusive（范围A）；
}
}
公共抽象类范围
{
公共摘要包含结论性内容（范围其他）；
}
公共类范围：范围
{
public T ValueFrom{get；set；}
公共T值{get；set；}
公共覆盖布尔包含结论（范围其他）
{
如果（其他为范围o）
{
返回Comparer.Default.Compare（o.ValueFrom，this.ValueTo）=0；
}
返回false；
}
}
这取决于
rangeA
和
rangeB
的数据类型

假设它们是
对象
，您可以这样做。如果您创建一个
范围
，然后对其调用
ContainsInclusive，它将在运行时引发异常。如果需要，可以添加额外的检查，但它会变得有点混乱，因为
Nullable
没有实现任何接口，所以必须求助于反射

public class Program
{
    public static void Main()
    {
        Foo(new Range<int>() { ValueFrom = 1, ValueTo = 10 }, new Range<int>() { ValueFrom = 0, ValueTo = 10 });
        Foo(new Range<int?>() { ValueFrom = 1, ValueTo = 10 }, new Range<int?>() { ValueFrom = 0, ValueTo = 10 });
    }
    
    private static bool Foo(object rangeA, object rangeB)
    {
        return (rangeA, rangeB) switch
        {
            (Range<int> a, Range<int> b) => b.ContainsInclusive(a),
            (Range<int?> a, Range<int?> b) => b.ContainsInclusive(a),
            _ => false,
        };
    }
}

public class Range<T> 
{
    public T ValueFrom { get; set; }
    public T ValueTo { get; set; }
    
    public bool ContainsInclusive(Range<T> other)
    {
        return Comparer<T>.Default.Compare(other.ValueFrom, this.ValueTo) <= 0 &&
            Comparer<T>.Default.Compare(other.ValueTo, this.ValueFrom) >= 0; 
    }
}


如果
rangeA
和
rangeB
可以是某个基本
Range
类型，那么您可以这样做。同样，如果
T
不可比较，则在运行时会抛出：

public class Program
{
    public static void Main()
    {
        Foo(new Range<int>() { ValueFrom = 1, ValueTo = 10 }, new Range<int>() { ValueFrom = 0, ValueTo = 10 }).Dump();
        Foo(new Range<int?>() { ValueFrom = 1, ValueTo = 10 }, new Range<int?>() { ValueFrom = 0, ValueTo = 10 }).Dump();
    }
    
    private static bool Foo(Range rangeA, Range rangeB)
    {
        return rangeB.ContainsInclusive(rangeA);
    }
}

public abstract class Range
{
    public abstract bool ContainsInclusive(Range other);
}

public class Range<T> : Range
{
    public T ValueFrom { get; set; }
    public T ValueTo { get; set; }
    
    public override bool ContainsInclusive(Range other)
    {
        if (other is Range<T> o)
        {
            return Comparer<T>.Default.Compare(o.ValueFrom, this.ValueTo) <= 0 &&
                Comparer<T>.Default.Compare(o.ValueTo, this.ValueFrom) >= 0;    
        }
        
        return false;
    }
}

公共类程序
{
公共静态void Main（）
{
Foo（新范围（）{ValueFrom=1，ValueTo=10}，新范围（）{ValueFrom=0，ValueTo=10}）；
Foo（新范围（）{ValueFrom=1，ValueTo=10}，新范围（）{ValueFrom=0，ValueTo=10}）；
}
专用静态bool Foo（范围A、范围B）
{
返回范围B.ContainsInclusive（范围A）；
}
}
公共抽象类范围
{
公共摘要包含结论性内容（范围其他）；
}
公共类范围：范围
{
public T ValueFrom{get；set；}
公共T值{get；set；}
公共覆盖布尔包含结论（范围其他）
{
如果（其他为范围o）
{
返回Comparer.Default.Compare（o.ValueFrom，this.ValueTo）=0；
}
返回false；
}
}
您还可以通过使用非抽象基类
范围来解决此问题。然后
Range
和
Range
都与该基类的赋值兼容

class Range
{
    public object ValueFrom { get; protected set; }
    public object ValueTo { get; protected set; }
}

class Range<T> : Range
{
    public new T ValueFrom
    {
        get {
            return (T)base.ValueFrom;
        }
        set {
            base.ValueFrom = value;
        }
    }

    public new T ValueTo
    {
        get {
            return (T)base.ValueTo;
        }
        set {
            base.ValueTo = value;
        }
    }
}


一个可能的改进是在泛型变量中使用强类型支持变量：

private T _valueFrom;
public new T ValueFrom
{
    get {
        return _valueFrom;
    }
    set {
        base.ValueFrom = _valueFrom = value;
    }
}

在处理泛型范围时，至少返回一个值不需要取消装箱。
您还可以通过使用非抽象基类
范围来解决此问题。然后
Range
和
Range
都与该基类的赋值兼容

class Range
{
    public object ValueFrom { get; protected set; }
    public object ValueTo { get; protected set; }
}

class Range<T> : Range
{
    public new T ValueFrom
    {
        get {
            return (T)base.ValueFrom;
        }
        set {
            base.ValueFrom = value;
        }
    }

    public new T ValueTo
    {
        get {
            return (T)base.ValueTo;
        }
        set {
            base.ValueTo = value;
        }
    }
}


一个可能的改进是在泛型变量中使用强类型支持变量：

private T _valueFrom;
public new T ValueFrom
{
    get {
        return _valueFrom;
    }
    set {
        base.ValueFrom = _valueFrom = value;
    }
}

在处理泛型范围时，至少返回一个值不需要取消装箱。
您的代码是什么？具体来说，你有什么问题？我不喜欢我有两个“相同”的案例，所以你想合并这两个案例，而不是拆分它们？啊，是的，我的错。。sry用于错误的单词
if
子句也是模式匹配。通过匹配
（rangeA，rangeB）
元组，您可以将它们包含在
case
子句中，而不是每次重复相同的检查。您拥有的代码是什么？具体来说，你有什么问题？我不喜欢我有两个“相同”的案例，所以你想合并这两个案例，而不是拆分它们？啊，是的，我的错。。sry用于错误的单词
if
子句也是模式匹配。您可以将它们包含在
case
子句中，而不是每次重复相同的检查，方法是匹配
（rangeA，rangeB）
tuple。。我仍然在处理我们公司使用C#7.3的问题，但这是一个很酷的解决方法，谢谢：）@Qhori查看我的编辑--这是另一个潜在的方法嗯，是的，你的最后一个代码片段帮助了。。我仍然在处理我们公司使用C#7.3的问题，但这是一个很酷的解决方法，谢谢：）@Qhori查看我的编辑--这是另一个可能的方法不，因为我需要一个大的开关，我想添加其他数据类型作为十进制，最好的版本已经添加了。。但是谢谢：）不，因为我需要一个大的开关，在这里我想添加其他数据类型，如十进制和