Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/CompareValidator.cs

@@ -0,0 +1,202 @@
+//------------------------------------------------------------------------------
+// <copyright file="CompareValidator.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls {
+
+    using System.ComponentModel;
+    using System.Web;
+    using System.Globalization;
+    using System.Web.Util;
+
+
+    /// <devdoc>
+    ///    <para> Compares the value of an input control to another input control or
+    ///       a constant value using a variety of operators and types.</para>
+    /// </devdoc>
+    [
+    ToolboxData("<{0}:CompareValidator runat=\"server\" ErrorMessage=\"CompareValidator\"></{0}:CompareValidator>")
+    ]
+    public class CompareValidator : BaseCompareValidator {
+
+
+        /// <devdoc>
+        ///    <para>Gets or sets the ID of the input control to compare with.</para>
+        /// </devdoc>
+        [
+        WebCategory("Behavior"),
+        Themeable(false),
+        DefaultValue(""),
+        WebSysDescription(SR.CompareValidator_ControlToCompare),
+        TypeConverter(typeof(ValidatedControlConverter))
+        ]                                         
+        public string ControlToCompare {
+            get { 
+                object o = ViewState["ControlToCompare"];
+                return((o == null) ? String.Empty : (string)o);
+            }
+            set {
+                ViewState["ControlToCompare"] = value;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets or sets the comparison operation to perform.</para>
+        /// </devdoc>
+        [
+        WebCategory("Behavior"),
+        Themeable(false),
+        DefaultValue(ValidationCompareOperator.Equal),
+        WebSysDescription(SR.CompareValidator_Operator)
+        ]                                         
+        public ValidationCompareOperator Operator {
+            get { 
+                object o = ViewState["Operator"];
+                return((o == null) ? ValidationCompareOperator.Equal : (ValidationCompareOperator)o);
+            }
+            set {
+                if (value < ValidationCompareOperator.Equal || value > ValidationCompareOperator.DataTypeCheck) {
+                    throw new ArgumentOutOfRangeException("value");
+                }
+                ViewState["Operator"] = value;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Gets or sets the specific value to compare with.</para>
+        /// </devdoc>
+        [
+        WebCategory("Behavior"),
+        Themeable(false),
+        DefaultValue(""),
+        WebSysDescription(SR.CompareValidator_ValueToCompare)
+        ]                                         
+        public string ValueToCompare {
+            get { 
+                object o = ViewState["ValueToCompare"];
+                return((o == null) ? String.Empty : (string)o);
+            }
+            set {
+                ViewState["ValueToCompare"] = value;
+            }        
+        }
+
+        // <summary>
+        //  AddAttributesToRender method
+        // </summary>
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    <para>Adds the attributes of this control to the output stream for rendering on the 
+        ///       client.</para>
+        /// </devdoc>
+        protected override void AddAttributesToRender(HtmlTextWriter writer) {
+            base.AddAttributesToRender(writer);
+            if (RenderUplevel) {
+                string id = ClientID;
+                HtmlTextWriter expandoAttributeWriter = (EnableLegacyRendering || IsUnobtrusive) ? writer : null;
+                AddExpandoAttribute(expandoAttributeWriter, id, "evaluationfunction", "CompareValidatorEvaluateIsValid", false);
+                if (ControlToCompare.Length > 0) {
+                    string controlToCompareID = GetControlRenderID(ControlToCompare);
+                    AddExpandoAttribute(expandoAttributeWriter, id, "controltocompare", controlToCompareID);
+                    AddExpandoAttribute(expandoAttributeWriter, id, "controlhookup", controlToCompareID);
+                }
+                if (ValueToCompare.Length > 0) {
+
+                    string valueToCompareString = ValueToCompare;
+                    if (CultureInvariantValues) {
+                        valueToCompareString = ConvertCultureInvariantToCurrentCultureFormat(valueToCompareString, Type);
+                    }
+                    AddExpandoAttribute(expandoAttributeWriter, id, "valuetocompare", valueToCompareString);
+                }
+                if (Operator != ValidationCompareOperator.Equal) {
+                    AddExpandoAttribute(expandoAttributeWriter, id, "operator", PropertyConverter.EnumToString(typeof(ValidationCompareOperator), Operator), false);
+                }
+            }
+        }        
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    <para> Checks the properties of a the control for valid values.</para>
+        /// </devdoc>
+        protected override bool ControlPropertiesValid() {
+
+            // Check the control id references 
+            if (ControlToCompare.Length > 0) {
+                CheckControlValidationProperty(ControlToCompare, "ControlToCompare");
+
+                if (StringUtil.EqualsIgnoreCase(ControlToValidate, ControlToCompare)) {
+                    throw new HttpException(SR.GetString(SR.Validator_bad_compare_control, 
+                                                                             ID, 
+                                                                             ControlToCompare));
+                }
+            }   
+            else {
+                // Check Values
+                if (Operator != ValidationCompareOperator.DataTypeCheck &&
+                    !CanConvert(ValueToCompare, Type, CultureInvariantValues)) {
+                        throw new HttpException(
+                                           SR.GetString(SR.Validator_value_bad_type, 
+                                                                           new string [] {
+                                                                               ValueToCompare,
+                                                                               "ValueToCompare",
+                                                                               ID, 
+                                                                               PropertyConverter.EnumToString(typeof(ValidationDataType), Type),
+                                                                           }));
+                }
+            }
+            return base.ControlPropertiesValid();
+        }
+
+
+        /// <internalonly/>
+        /// <devdoc>
+        ///    EvaluateIsValid method
+        /// </devdoc>
+        protected override bool EvaluateIsValid() {
+
+            Debug.Assert(PropertiesValid, "Properties should have already been checked");
+
+            // Get the peices of text from the control.
+            string leftText = GetControlValidationValue(ControlToValidate);
+            Debug.Assert(leftText != null, "Should have already caught this!");
+
+            // Special case: if the string is blank, we don't try to validate it. The input should be
+            // trimmed for coordination with the RequiredFieldValidator.
+            if (leftText.Trim().Length == 0) {
+                return true;
+            }
+
+            // VSWhidbey 83168
+            bool convertDate = (Type == ValidationDataType.Date && !DetermineRenderUplevel());
+            if (convertDate && !IsInStandardDateFormat(leftText)) {
+                leftText = ConvertToShortDateString(leftText);
+            }
+
+            // The control has precedence over the fixed value
+            bool isCultureInvariantValue = false;
+            string rightText = string.Empty;
+            if (ControlToCompare.Length > 0) {
+                rightText = GetControlValidationValue(ControlToCompare);
+                Debug.Assert(rightText != null, "Should have already caught this!");
+
+                // VSWhidbey 83089
+                if (convertDate && !IsInStandardDateFormat(rightText)) {
+                    rightText = ConvertToShortDateString(rightText);
+                }
+            }
+            else {
+                rightText = ValueToCompare;
+                isCultureInvariantValue = CultureInvariantValues;
+            }
+
+            return Compare(leftText, false, rightText, isCultureInvariantValue, Operator, Type);
+
+        }
+    }
+}