Allow RangeAttribute use to request InvariantCulture conversions. (#25918)

* Allow RangeAttribute use to request InvariantCulture conversions.

Adds a ParseLimitsInInvariantCulture that affects the interpretation of
the extrema set, and ConvertValueInInvariantCulture that affects the
interpretation of values.

Separate methods allows for e.g. a component assuming a
dot-decimal-separator culture defining a property with the attribute
(so invariant culture should be used) the use of the property is done
in a comma-decimal-separator (so the current culture should be used),
or any permutation of the two booleans.

Fixes #2648

* Skip NetFX on associated tests.

* Update tests in #25918 to work with changes from #26050

Author: JonHanna

src/System.ComponentModel.Annotations/ref/System.ComponentModel.Annotations.cs

@@ -204,9 +204,11 @@ public partial class RangeAttribute : System.ComponentModel.DataAnnotations.Vali
         public RangeAttribute(double minimum, double maximum) { }
         public RangeAttribute(int minimum, int maximum) { }
         public RangeAttribute(System.Type type, string minimum, string maximum) { }
+        public bool ConvertValueInInvariantCulture { get { throw null; } set { } }
         public object Maximum { get { throw null; } }
         public object Minimum { get { throw null; } }
         public System.Type OperandType { get { throw null; } }
+        public bool ParseLimitsInInvariantCulture { get { throw null; } set { } }
         public override string FormatErrorMessage(string name) { throw null; }
         public override bool IsValid(object value) { throw null; }
     }

src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/RangeAttribute.cs

@@ -70,6 +70,21 @@ public RangeAttribute(Type type, string minimum, string maximum)
         /// </summary>
         public Type OperandType { get; }
 
+        /// <summary>
+        /// Determines whether string values for <see cref="Minimum"/> and <see cref="Maximum"/> are parsed in the invariant
+        /// culture rather than the current culture in effect at the time of the validation.
+        /// </summary>
+        public bool ParseLimitsInInvariantCulture { get; set; }
+
+        /// <summary>
+        /// Determines whether any conversions necessary from the value being validated to <see cref="OperandType"/> as set
+        /// by the <c>type</c> parameter of the <see cref="RangeAttribute(Type, string, string)"/> constructor are carried
+        /// out in the invariant culture rather than the current culture in effect at the time of the validation.
+        /// </summary>
+        /// <remarks>This property has no effects with the constructors with <see cref="int"/> or <see cref="double"/>
+        /// parameters, for which the invariant culture is always used for any conversions of the validated value.</remarks>
+        public bool ConvertValueInInvariantCulture { get; set; }
+
         private Func<object, object> Conversion { get; set; }
 
         private void Initialize(IComparable minimum, IComparable maximum, Func<object, object> conversion)
@@ -192,10 +207,25 @@ private void SetupConversion()
                     }
 
                     TypeConverter converter = TypeDescriptor.GetConverter(type);
-                    IComparable min = (IComparable)converter.ConvertFromString((string)minimum);
-                    IComparable max = (IComparable)converter.ConvertFromString((string)maximum);
+                    IComparable min = (IComparable)(ParseLimitsInInvariantCulture
+                        ? converter.ConvertFromInvariantString((string)minimum)
+                        : converter.ConvertFromString((string)minimum));
+                    IComparable max = (IComparable)(ParseLimitsInInvariantCulture
+                        ? converter.ConvertFromInvariantString((string)maximum)
+                        : converter.ConvertFromString((string)maximum));
+
+                    Func<object, object> conversion;
+                    if (ConvertValueInInvariantCulture)
+                    {
+                        conversion = value => value?.GetType() == type
+                            ? value
+                            : converter.ConvertFrom(null, CultureInfo.InvariantCulture, value);
+                    }
+                    else
+                    {
+                        conversion = value => value?.GetType() == type ? value : converter.ConvertFrom(value);
+                    }
 
-                    Func<object, object> conversion = value => (value != null && value.GetType() == type) ? value : converter.ConvertFrom(value);
                     Initialize(min, max, conversion);
                 }
             }