CompareValidator.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / CompareValidator.cs / 1305376 / CompareValidator.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System.ComponentModel;
    using System.Web; 
    using System.Globalization;
    using System.Web.Util;

 
    /// 
    ///     Compares the value of an input control to another input control or 
    ///       a constant value using a variety of operators and types. 
    /// 
    [ 
    ToolboxData("<{0}:CompareValidator runat=\"server\" ErrorMessage=\"CompareValidator\">")
    ]
    public class CompareValidator : BaseCompareValidator {
 

        ///  
        ///    Gets or sets the ID of the input control to compare with. 
        /// 
        [ 
        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; 
            }
        } 
 

        ///  
        ///    Gets or sets the comparison operation to perform.
        /// 
        [
        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; 
            }
        }

 
        /// 
        ///    Gets or sets the specific value to compare with. 
        ///  
        [
        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;
            }
        } 

        //  
        //  AddAttributesToRender method 
        // 
 
        /// 
        /// 
        ///    Adds the attributes of this control to the output stream for rendering on the
        ///       client. 
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) { 
            base.AddAttributesToRender(writer); 
            if (RenderUplevel) {
                string id = ClientID; 
                HtmlTextWriter expandoAttributeWriter = (EnableLegacyRendering) ? 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);
                } 
            }
        }

 
        /// 
        ///  
        ///     Checks the properties of a the control for valid values. 
        /// 
        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(); 
        }


        ///  
        /// 
        ///    EvaluateIsValid method 
        ///  
        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); 

        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK