CompareValidator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebControls / CompareValidator.cs / 1 / 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.Security.Permissions;
    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\">")
    ]
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    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);
 
        }
    } 
}

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