Алгоритм поиска по выражениям больше/меньше

public class RangeValue: Entity
    {
//Тип объекта
        public virtual BusinessObject BusinessObject { get; set; }
//Левая граница диапазона. Если null - то минус бесконечность
        public virtual double? MinValue { get; set; }
//Правая граница диапазона. Если null - то плюс бесконечность
        public virtual double? MaxValue { get; set; }
//Тип строгости левой/правой границ (включая/не включая границу)
        public virtual TypeOfBorderStrong TypeOfBorderStrong { get; set; }
//Результат, если искомое значение попадает в диапазон
        public virtual double BOValue { get; set; }
    }
 
//Совпадение найдено! Условие досрочного выхода из цикла
 bool Match = false;
 
                for (int i = 0; i < rangeValues.Count && !Match; i++)
                {
                    switch (rangeValues[i].TypeOfBorderStrong.Id)
                    {
                        case (int)BorderStrongTypeId.LeftExcludeRightExclude:
                            if (rangeValues[i].MinValue < temp && rangeValues[i].MaxValue > temp)
                            {
                                result = rangeValues[i].BOValue;
                                Match = true;
                            }
                            break;
                        case (int)BorderStrongTypeId.LeftExcludeRightInclude:
                            if (rangeValues[i].MinValue < temp && rangeValues[i].MaxValue >= temp)
                            {
                                result = rangeValues[i].BOValue;
                                Match = true;
                            }
                            break;
                        case (int)BorderStrongTypeId.LeftIncludeRightExclude:
                            if (rangeValues[i].MinValue <= temp && rangeValues[i].MaxValue > temp)
                            {
                                result = rangeValues[i].BOValue;
                                Match = true;
                            }
                            break;
                        case (int)BorderStrongTypeId.LeftIncludeRightInclude:
                            if (rangeValues[i].MinValue <= temp && rangeValues[i].MaxValue >= temp)
                            {
                                result = rangeValues[i].BOValue;
                                Match = true;
                            }
                            break;
                        default:
                            result = 0;
                            break;
                    }
                }

if (
            (rangeValues[i].MinValue < temp && rangeValues[i].MaxValue > temp) && rangeValues[i].TypeOfBorderStrong.Id == (int)BorderStrongTypeId.LeftExcludeRightExclude||
            (rangeValues[i].MinValue < temp && rangeValues[i].MaxValue >= temp) && rangeValues[i].TypeOfBorderStrong.Id == (int)BorderStrongTypeId.LeftExcludeRightInclude||
            (rangeValues[i].MinValue <= temp && rangeValues[i].MaxValue > temp) && rangeValues[i].TypeOfBorderStrong.Id == (int)BorderStrongTypeId.LeftIncludeRightExclude||
            (rangeValues[i].MinValue <= temp && rangeValues[i].MaxValue >= temp) && rangeValues[i].TypeOfBorderStrong.Id == (int)BorderStrongTypeId.LeftIncludeRightInclude
            )
        {
            result = rangeValues[i].BOValue;
            Match = true;
        }

    public enum BorderStrongTypeId
    {
        LeftExcludeRightExclude,
        LeftExcludeRightInclude,
        LeftIncludeRightExclude,
        LeftIncludeRightInclude
    }
 
    public class TypeOfBorderStrong
    {
        public BorderStrongTypeId Id { get; set; }
    }
 
    public class RangeValue// : Entity
    {
        //Тип объекта
        //public virtual BusinessObject BusinessObject { get; set; }
        //Левая граница диапазона. Если null - то минус бесконечность
        public virtual double? MinValue { get; set; }
        //Правая граница диапазона. Если null - то плюс бесконечность
        public virtual double? MaxValue { get; set; }
        //Тип строгости левой/правой границ (включая/не включая границу)
        public virtual TypeOfBorderStrong TypeOfBorderStrong { get; set; }
        //Результат, если искомое значение попадает в диапазон
        public virtual double BOValue { get; set; }
 
        public bool IsInRange(double value)
        {
            double min = MinValue ?? double.NegativeInfinity;
            double max = MaxValue ?? double.NegativeInfinity;
            switch (TypeOfBorderStrong.Id)
            {
                case BorderStrongTypeId.LeftExcludeRightExclude:
                    return min < value && max > value;
                case BorderStrongTypeId.LeftExcludeRightInclude:
                    return min < value && max >= value;
                case BorderStrongTypeId.LeftIncludeRightExclude:
                    return min <= value && max > value;
                case BorderStrongTypeId.LeftIncludeRightInclude:
                    return min <= value && max >= value;
            }
            return false;
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            var rangeValues = new List<RangeValue>
            {
                new RangeValue { MinValue = null, MaxValue = 10, BOValue = 0, TypeOfBorderStrong = new TypeOfBorderStrong { Id = BorderStrongTypeId.LeftExcludeRightExclude} },
                new RangeValue { MinValue = 10, MaxValue = 15, BOValue = 0.5, TypeOfBorderStrong = new TypeOfBorderStrong { Id = BorderStrongTypeId.LeftExcludeRightExclude} },
                new RangeValue { MinValue = 15, MaxValue = 20, BOValue = 1, TypeOfBorderStrong = new TypeOfBorderStrong { Id = BorderStrongTypeId.LeftExcludeRightExclude} },
                new RangeValue { MinValue = 20, MaxValue = 25, BOValue = 1.5, TypeOfBorderStrong = new TypeOfBorderStrong { Id = BorderStrongTypeId.LeftExcludeRightExclude} },
                new RangeValue { MinValue = 25, MaxValue = null, BOValue = 1.5, TypeOfBorderStrong = new TypeOfBorderStrong { Id = BorderStrongTypeId.LeftExcludeRightExclude} }
            };
 
            double v = 11;
 
            RangeValue rw = rangeValues.FirstOrDefault(r => r.IsInRange(v));
 
            double res = rw?.BOValue ?? 0;
 
            Console.WriteLine($"Value {res}");
 
            Console.ReadKey();
        }
    }

    public class RangeValue
    {
        /// <summary>Поле для хранения значения делегата функции</summary>
        private RangeExpression _expression;
 
        /// <summary>Делегат определяющий попадание в диапазон</summary>
        /// <param name="Range">Граница диапазона</param>
        /// <param name="Value">Значение</param>
        /// <returns>True если значение попадает в диапазон</returns>
        public delegate bool RangeExpression(double Range, double Value);
 
        /// <summary>Метод-свойство устанавливающий функцию сравнения</summary>
        public RangeExpression SetExpression { set => _expression = value; }
 
        /// <summary>Граница диапазона</summary>
        public double SourceValue { get; set; }
        /// <summary>Присваиваемое значение</summary>
        public double BOValue { get; set; }
 
        /// <summary>Метод вычисляющий попадание в диапазон</summary>
        /// <param name="Value">Значение для которого определяется попадание в диапазон</param>
        /// <returns>True если значение попало в диапазон</returns>
        public bool IsExpression(double Value)
            => _expression != null && _expression(SourceValue, Value);
 
        static public double CalcExpressions(double Value, List<RangeValue> Expressions, double DefaultValue = 0)
        {
            RangeValue expression = Expressions.OrderBy(expr => expr.SourceValue).FirstOrDefault(expr => expr.IsExpression(Value));
            return expression == null ? DefaultValue : expression.BOValue;
        }
    }

        static public void Main()
        {
            bool IsLessOrEqual(double Range, double Value) => Value <= Range;
            bool IsMore(double Range, double Value) => Value > Range;
 
            List<RangeValue> Expressions = new List<RangeValue>()
            {
                new RangeValue() {SourceValue=25, BOValue=2, SetExpression=IsMore},
                new RangeValue() {SourceValue=15, BOValue=0.5, SetExpression=IsLessOrEqual},
                new RangeValue() {SourceValue=20, BOValue=1, SetExpression=IsLessOrEqual},
                new RangeValue() {SourceValue=25, BOValue=1.5, SetExpression=IsLessOrEqual},
                new RangeValue() {SourceValue=10, BOValue=0, SetExpression=IsLessOrEqual}
            };
 
            for (int ind = 5; ind < 30; ind++)
                Console.WriteLine($" A={ind}, B={RangeValue.CalcExpressions(ind, Expressions, -100)}");
        }

double res;
if (rw != null)
    res = rw.BOValue;
else
    res = 0;

double res = rw != null ? rw.BOValue : 0;

double max = MaxValue ?? double.NegativeInfinity; // тут должно быть быть PositiveInfinity...

RangeValue rw = rangeValues.FirstOrDefault(r => r.IsInRange(v));