public abstract class ValueBase
{
        public abstract Type GetValueType();
}

public class Value<T>:ValueBase 
    {

        public bool CheckValue(T value)
        {
            .....
            return res;
        }

        public override Type GetValueType()
        {
            return typeof(T);
        }
    }

//Использование
private List<ValueBase> m_Keys = new List<ValueBase>();



 public void Set(float value)
        {
                var floatValues = from suppValue in this.m_Keys 
                                  where suppValue.GetValueType().Equals(typeof(float)) 
                                  select suppValue as Value<float>;

                foreach (Value<float> suppValue in floatValues)
                {
                    if (!suppValue.CheckValue(value))
                    {
                      .......
                    }
                }

        }

var mkeys = List<object>();

var floatValues = from suppValue in this.m_Keys 
                  where suppvalue is float
                  select (float)suppValue;

                foreach (Value<float> suppValue in floatValues)
                {
                    if (!checker.CheckValue(suppValue))
                    {
                      .......
                    }
                }

Z>var mkeys = List<object>();

Z>var floatValues = from suppValue in this.m_Keys 
Z>                  where suppvalue is float
Z>                  select (float)suppValue;

Z>                foreach (Value<float> suppValue in floatValues)
Z>                {
Z>                    if (!checker.CheckValue(suppValue))
Z>                    {
Z>                      .......
Z>                    }
Z>                }

Z>

public class Value<T>:ValueBase 
    {
        private T m_value;
        public T Value
        {
            get { return m_value; }
            set { m_value = value; }
        }

        private T m_low;
        public T Low
        {
            get { return m_low; } 
        }

        private T m_high;
        public T High
        {
            get { return m_high; }
        }
}

S>public abstract class ValueBase
S>{
S>        public abstract Type GetValueType();
S>}

S>Как то так

        public interface IConstraint<T>
        {
                        string Description { get; }
            bool CheckValue(T val);
        }

        public interface ISelectConstraint<T> : IConstraint<T>
          where T : IEquatable<T>
        {
            IEnumerable<T> GetValidValues();
        }

        public interface IRangeConstraint<T> : IConstraint<T>
            where T : IComparable<T>
        {
            T Minimum { get; }
            T Maximum { get; }
        }

                // необязательный хелпер для уверенности в том, что значение всегда валидно
        public class ConstraintedValue<T, C>
          where C : IConstraint<T>
        {
            private T val;
            private readonly C constraint;

            public T Value
            {
                get { return val;}
                set
                {
                    if (!constraint.CheckValue(value))
                        throw new ApplicationException("value");

                    val = value;
                }
            }

            public C Constraint
            {
                get { return constraint; }
            }

            public ConstraintedValue(C constraint, T val)
            {
                this.constraint = constraint;
                this.val = val;
            }
        }