basecomparevalidator.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

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

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

namespace System.Web.UI.WebControls { 
 
    using System.ComponentModel;
    using System.Drawing; 
    using System.Globalization;
    using System.Web;
    using System.Web.UI.HtmlControls;
    using System.Text.RegularExpressions; 
    using System.Text;
    using System.Web.Util; 
 

    ///  
    ///     Serves as the abstract base
    ///       class for validators that do typed comparisons.
    /// 
    public abstract class BaseCompareValidator : BaseValidator { 

 
        ///  
        ///    Gets or sets the data type that specifies how the values
        ///       being compared should be interpreted. 
        /// 
        [
        WebCategory("Behavior"),
        Themeable(false), 
        DefaultValue(ValidationDataType.String),
        WebSysDescription(SR.RangeValidator_Type) 
        ] 
        public ValidationDataType Type {
            get { 
                object o = ViewState["Type"];
                return((o == null) ? ValidationDataType.String : (ValidationDataType)o);
            }
            set { 
                if (value < ValidationDataType.String || value > ValidationDataType.Currency) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                ViewState["Type"] = value;
            } 
        }


        ///  
        ///     Whether we should do culture invariant conversion against the
        ///     string value properties on the control 
        ///  
        [
        WebCategory("Behavior"), 
        Themeable(false),
        DefaultValue(false),
        WebSysDescription(SR.BaseCompareValidator_CultureInvariantValues)
        ] 
        public bool CultureInvariantValues {
            get { 
                object o = ViewState["CultureInvariantValues"]; 
                return((o == null) ? false : (bool)o);
            } 
            set {
                ViewState["CultureInvariantValues"] = value;
            }
        } 

 
        ///  
        /// 
        ///    AddAttributesToRender method 
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) {
            base.AddAttributesToRender(writer);
            if (RenderUplevel) { 
                ValidationDataType type = Type;
                if (type != ValidationDataType.String) { 
                    string id = ClientID; 
                    HtmlTextWriter expandoAttributeWriter = (EnableLegacyRendering) ? writer : null;
 
                    AddExpandoAttribute(expandoAttributeWriter, id, "type", PropertyConverter.EnumToString(typeof(ValidationDataType), type), false);

                    NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
                    if (type == ValidationDataType.Double) { 
                        string decimalChar = info.NumberDecimalSeparator;
                        AddExpandoAttribute(expandoAttributeWriter, id, "decimalchar", decimalChar); 
                    } 
                    else if (type == ValidationDataType.Currency) {
                        string decimalChar = info.CurrencyDecimalSeparator; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "decimalchar", decimalChar);

                        string groupChar = info.CurrencyGroupSeparator;
                        // Map non-break space onto regular space for parsing 
                        if (groupChar[0] == 160)
                            groupChar = " "; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "groupchar", groupChar); 

                        int digits = info.CurrencyDecimalDigits; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "digits", digits.ToString(NumberFormatInfo.InvariantInfo), false);

                        // VSWhidbey 83165
                        int groupSize = GetCurrencyGroupSize(info); 
                        if (groupSize > 0) {
                            AddExpandoAttribute(expandoAttributeWriter, id, "groupsize", groupSize.ToString(NumberFormatInfo.InvariantInfo), false); 
                        } 
                    }
                    else if (type == ValidationDataType.Date) { 
                        AddExpandoAttribute(expandoAttributeWriter, id, "dateorder", GetDateElementOrder(), false);
                        AddExpandoAttribute(expandoAttributeWriter, id, "cutoffyear", CutoffYear.ToString(NumberFormatInfo.InvariantInfo), false);

                        // VSWhidbey 504553: The changes of this bug make client-side script not 
                        // using the century attribute anymore, but still generating it for
                        // backward compatibility with Everett pages. 
                        int currentYear = DateTime.Today.Year; 
                        int century = currentYear - (currentYear % 100);
                        AddExpandoAttribute(expandoAttributeWriter, id, "century", century.ToString(NumberFormatInfo.InvariantInfo), false); 
                    }
                }
            }
        } 

 
 
        /// 
        ///    Check if the text can be converted to the type 
        /// 
        public static bool CanConvert(string text, ValidationDataType type) {
            return CanConvert(text, type, false);
        } 

 
        public static bool CanConvert(string text, ValidationDataType type, bool cultureInvariant) { 
            object value = null;
            return Convert(text, type, cultureInvariant, out value); 
        }


        ///  
        /// 
        ///    Return the order of date elements for the current culture 
        ///  
        protected static string GetDateElementOrder() {
            DateTimeFormatInfo info = DateTimeFormatInfo.CurrentInfo; 
            string shortPattern = info.ShortDatePattern;
            if (shortPattern.IndexOf('y') < shortPattern.IndexOf('M')) {
                return "ymd";
            } 
            else if (shortPattern.IndexOf('M') < shortPattern.IndexOf('d')) {
                return "mdy"; 
            } 
            else {
                return "dmy"; 
            }
        }

        // VSWhidbey 83165 
        private static int GetCurrencyGroupSize(NumberFormatInfo info) {
            int [] groupSizes = info.CurrencyGroupSizes; 
            if (groupSizes != null && groupSizes.Length == 1) { 
                return groupSizes[0];
            } 
            else {
                return -1;
            }
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        protected static int CutoffYear {
            get {
                return DateTimeFormatInfo.CurrentInfo.Calendar.TwoDigitYearMax;
            } 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        protected static int GetFullYear(int shortYear) {
            Debug.Assert(shortYear >= 0 && shortYear < 100);
            return DateTimeFormatInfo.CurrentInfo.Calendar.ToFourDigitYear(shortYear); 
        }
 
 
        /// 
        ///    Try to convert the test into the validation data type 
        /// 
        protected static bool Convert(string text, ValidationDataType type, out object value) {
            return Convert(text, type, false, out value);
        } 

 
        protected static bool Convert(string text, ValidationDataType type, bool cultureInvariant, out object value) { 

            value = null; 
            try {
                switch (type) {
                    case ValidationDataType.String:
                        value = text; 
                        break;
 
                    case ValidationDataType.Integer: 
                        value = Int32.Parse(text, CultureInfo.InvariantCulture);
                        break; 

                    case ValidationDataType.Double: {
                        string cleanInput;
                        if (cultureInvariant) { 
                            cleanInput = ConvertDouble(text, CultureInfo.InvariantCulture.NumberFormat);
                        } 
                        else { 
                            cleanInput = ConvertDouble(text, NumberFormatInfo.CurrentInfo);
                        } 

                        if (cleanInput != null) {
                            value = Double.Parse(cleanInput, CultureInfo.InvariantCulture);
                        } 
                        break;
                    } 
 
                    case ValidationDataType.Date: {
                        if (cultureInvariant) { 
                            value = ConvertDate(text, "ymd");
                        }
                        else {
                            // if the calendar is not gregorian, we should not enable client-side, so just parse it directly: 
                            if (!(DateTimeFormatInfo.CurrentInfo.Calendar.GetType() == typeof(GregorianCalendar))) {
                                value = DateTime.Parse(text, CultureInfo.CurrentCulture); 
                                break; 
                            }
 
                            string dateElementOrder = GetDateElementOrder();
                            value = ConvertDate(text, dateElementOrder);
                        }
                        break; 
                    }
 
                    case ValidationDataType.Currency: { 
                        string cleanInput;
                        if (cultureInvariant) { 
                            cleanInput = ConvertCurrency(text, CultureInfo.InvariantCulture.NumberFormat);
                        }
                        else {
                            cleanInput = ConvertCurrency(text, NumberFormatInfo.CurrentInfo); 
                        }
 
                        if (cleanInput != null) { 
                            value = Decimal.Parse(cleanInput, CultureInfo.InvariantCulture);
                        } 
                        break;
                    }
                }
            } 
            catch {
                value = null; 
            } 
            return (value != null);
        } 

        private static string ConvertCurrency(string text, NumberFormatInfo info) {
            string decimalChar = info.CurrencyDecimalSeparator;
            string groupChar = info.CurrencyGroupSeparator; 

            // VSWhidbey 83165 
            string beginGroupSize, subsequentGroupSize; 
            int groupSize = GetCurrencyGroupSize(info);
            if (groupSize > 0) { 
                string groupSizeText = groupSize.ToString(NumberFormatInfo.InvariantInfo);
                beginGroupSize = "{1," + groupSizeText + "}";
                subsequentGroupSize = "{" + groupSizeText + "}";
            } 
            else {
                beginGroupSize = subsequentGroupSize = "+"; 
            } 

            // Map non-break space onto regular space for parsing 
            if (groupChar[0] == 160)
                groupChar = " ";
            int digits = info.CurrencyDecimalDigits;
            bool hasDigits = (digits > 0); 
            string currencyExpression =
                "^\\s*([-\\+])?((\\d" + beginGroupSize + "(\\" + groupChar + "\\d" + subsequentGroupSize + ")+)|\\d*)" 
                + (hasDigits ? "\\" + decimalChar + "?(\\d{0," + digits.ToString(NumberFormatInfo.InvariantInfo) + "})" : string.Empty) 
                + "\\s*$";
 
            Match m = Regex.Match(text, currencyExpression);
            if (!m.Success) {
                return null;
            } 

            // Make sure there are some valid digits 
            if (m.Groups[2].Length == 0 && hasDigits && m.Groups[5].Length == 0) { 
                return null;
            } 

            return m.Groups[1].Value
                   + m.Groups[2].Value.Replace(groupChar, string.Empty)
                   + ((hasDigits && m.Groups[5].Length > 0) ? "." + m.Groups[5].Value : string.Empty); 
        }
 
        private static string ConvertDouble(string text, NumberFormatInfo info) { 
            // VSWhidbey 83156: If text is empty, it would be default to 0 for
            // backward compatibility reason. 
            if (text.Length == 0) {
                return "0";
            }
 
            string decimalChar = info.NumberDecimalSeparator;
            string doubleExpression = "^\\s*([-\\+])?(\\d*)\\" + decimalChar + "?(\\d*)\\s*$"; 
 
            Match m = Regex.Match(text, doubleExpression);
            if (!m.Success) { 
                return null;
            }

            // Make sure there are some valid digits 
            if (m.Groups[2].Length == 0 && m.Groups[3].Length == 0) {
                return null; 
            } 

            return m.Groups[1].Value 
                   + (m.Groups[2].Length > 0 ? m.Groups[2].Value : "0")
                   + ((m.Groups[3].Length > 0) ? "." + m.Groups[3].Value: string.Empty);
        }
 
        // ***************************************************************************************************************
        // **                                                                                                            ** 
        // ** NOTE: When updating the regular expressions in this method, you must also update the regular expressions   ** 
        // **       in WebUIValidation.js::ValidatorConvert().  The server and client regular expressions must match.    **
        // **                                                                                                            ** 
        // ***************************************************************************************************************
        private static object ConvertDate(string text, string dateElementOrder) {
            // always allow the YMD format, if they specify 4 digits
            string dateYearFirstExpression = "^\\s*((\\d{4})|(\\d{2}))([-/]|\\. ?)(\\d{1,2})\\4(\\d{1,2})\\.?\\s*$"; 
            Match m = Regex.Match(text, dateYearFirstExpression);
            int day, month, year; 
            if (m.Success && (m.Groups[2].Success || dateElementOrder == "ymd")) { 
                day = Int32.Parse(m.Groups[6].Value, CultureInfo.InvariantCulture);
                month = Int32.Parse(m.Groups[5].Value, CultureInfo.InvariantCulture); 
                if (m.Groups[2].Success) {
                    year = Int32.Parse(m.Groups[2].Value, CultureInfo.InvariantCulture);
                }
                else { 
                    year = GetFullYear(Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture));
                } 
            } 
            else {
                if (dateElementOrder == "ymd") { 
                    return null;
                }

                // also check for the year last format 
                string dateYearLastExpression = "^\\s*(\\d{1,2})([-/]|\\. ?)(\\d{1,2})(?:\\s|\\2)((\\d{4})|(\\d{2}))(?:\\s\u0433\\.|\\.)?\\s*$";
                m = Regex.Match(text, dateYearLastExpression); 
                if (!m.Success) { 
                    return null;
                } 
                if (dateElementOrder == "mdy") {
                    day = Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture);
                    month = Int32.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture);
                } 
                else {
                    day = Int32.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture); 
                    month = Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture); 
                }
                if (m.Groups[5].Success) { 
                    year = Int32.Parse(m.Groups[5].Value, CultureInfo.InvariantCulture);
                } else {
                    year = GetFullYear(Int32.Parse(m.Groups[6].Value, CultureInfo.InvariantCulture));
                } 
            }
            return new DateTime(year, month, day); 
        } 

 
        /// 
        ///    Compare two strings using the type and operator
        /// 
        protected static bool Compare(string leftText, string rightText, ValidationCompareOperator op, ValidationDataType type) { 
            return Compare(leftText, false, rightText, false, op, type);
        } 
 

        protected static bool Compare(string leftText, bool cultureInvariantLeftText, 
                                      string rightText, bool cultureInvariantRightText,
                                      ValidationCompareOperator op, ValidationDataType type) {
            object leftObject;
            if (!Convert(leftText, type, cultureInvariantLeftText, out leftObject)) 
                return false;
 
            if (op == ValidationCompareOperator.DataTypeCheck) 
                return true;
 
            object rightObject;
            if (!Convert(rightText, type, cultureInvariantRightText, out rightObject))
                return true;
 
            int compareResult;
            switch (type) { 
                case ValidationDataType.String: 
                    compareResult = String.Compare((string)leftObject, (string) rightObject, false, CultureInfo.CurrentCulture);
                    break; 

                case ValidationDataType.Integer:
                    compareResult = ((int)leftObject).CompareTo(rightObject);
                    break; 

                case ValidationDataType.Double: 
                    compareResult = ((double)leftObject).CompareTo(rightObject); 
                    break;
 
                case ValidationDataType.Date:
                    compareResult = ((DateTime)leftObject).CompareTo(rightObject);
                    break;
 
                case ValidationDataType.Currency:
                    compareResult = ((Decimal)leftObject).CompareTo(rightObject); 
                    break; 

                default: 
                    Debug.Fail("Unknown Type");
                    return true;
            }
 
            switch (op) {
                case ValidationCompareOperator.Equal: 
                    return compareResult == 0; 
                case ValidationCompareOperator.NotEqual:
                    return compareResult != 0; 
                case ValidationCompareOperator.GreaterThan:
                    return compareResult > 0 ;
                case ValidationCompareOperator.GreaterThanEqual:
                    return compareResult >= 0 ; 
                case ValidationCompareOperator.LessThan:
                    return compareResult < 0 ; 
                case ValidationCompareOperator.LessThanEqual: 
                    return compareResult <= 0 ;
                default: 
                    Debug.Fail("Unknown Operator");
                    return true;
            }
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        protected override bool DetermineRenderUplevel() {
            // We don't do client-side validation for dates with non gregorian calendars
            if (Type == ValidationDataType.Date && DateTimeFormatInfo.CurrentInfo.Calendar.GetType() != typeof(GregorianCalendar)) {
                return false; 
            }
            return base.DetermineRenderUplevel(); 
        } 

        internal string ConvertToShortDateString(string text) { 
            // VSWhidbey 83099, 85305, we should ignore error if it happens and
            // leave text as intact when parsing the date.  We assume the caller
            // (validator) is able to handle invalid text itself.
            DateTime date; 
            if (DateTime.TryParse(text, CultureInfo.CurrentCulture, DateTimeStyles.None, out date)) {
                text = date.ToShortDateString(); 
            } 
            return text;
        } 

        internal bool IsInStandardDateFormat(string date) {
            // VSWhidbey 115454: We identify that date string with only numbers
            // and specific punctuation separators is in standard date format. 
            const string standardDateExpression = "^\\s*(\\d+)([-/]|\\. ?)(\\d+)\\2(\\d+)\\s*$";
            return Regex.Match(date, standardDateExpression).Success; 
        } 

        internal string ConvertCultureInvariantToCurrentCultureFormat(string valueInString, 
                                                                      ValidationDataType type) {
            object value;
            Convert(valueInString, type, true, out value);
            if (value is DateTime) { 
                // For Date type we explicitly want the date portion only
                return ((DateTime) value).ToShortDateString(); 
            } 
            else {
                return System.Convert.ToString(value, CultureInfo.CurrentCulture); 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls { 
 
    using System.ComponentModel;
    using System.Drawing; 
    using System.Globalization;
    using System.Web;
    using System.Web.UI.HtmlControls;
    using System.Text.RegularExpressions; 
    using System.Text;
    using System.Web.Util; 
 

    ///  
    ///     Serves as the abstract base
    ///       class for validators that do typed comparisons.
    /// 
    public abstract class BaseCompareValidator : BaseValidator { 

 
        ///  
        ///    Gets or sets the data type that specifies how the values
        ///       being compared should be interpreted. 
        /// 
        [
        WebCategory("Behavior"),
        Themeable(false), 
        DefaultValue(ValidationDataType.String),
        WebSysDescription(SR.RangeValidator_Type) 
        ] 
        public ValidationDataType Type {
            get { 
                object o = ViewState["Type"];
                return((o == null) ? ValidationDataType.String : (ValidationDataType)o);
            }
            set { 
                if (value < ValidationDataType.String || value > ValidationDataType.Currency) {
                    throw new ArgumentOutOfRangeException("value"); 
                } 
                ViewState["Type"] = value;
            } 
        }


        ///  
        ///     Whether we should do culture invariant conversion against the
        ///     string value properties on the control 
        ///  
        [
        WebCategory("Behavior"), 
        Themeable(false),
        DefaultValue(false),
        WebSysDescription(SR.BaseCompareValidator_CultureInvariantValues)
        ] 
        public bool CultureInvariantValues {
            get { 
                object o = ViewState["CultureInvariantValues"]; 
                return((o == null) ? false : (bool)o);
            } 
            set {
                ViewState["CultureInvariantValues"] = value;
            }
        } 

 
        ///  
        /// 
        ///    AddAttributesToRender method 
        /// 
        protected override void AddAttributesToRender(HtmlTextWriter writer) {
            base.AddAttributesToRender(writer);
            if (RenderUplevel) { 
                ValidationDataType type = Type;
                if (type != ValidationDataType.String) { 
                    string id = ClientID; 
                    HtmlTextWriter expandoAttributeWriter = (EnableLegacyRendering) ? writer : null;
 
                    AddExpandoAttribute(expandoAttributeWriter, id, "type", PropertyConverter.EnumToString(typeof(ValidationDataType), type), false);

                    NumberFormatInfo info = NumberFormatInfo.CurrentInfo;
                    if (type == ValidationDataType.Double) { 
                        string decimalChar = info.NumberDecimalSeparator;
                        AddExpandoAttribute(expandoAttributeWriter, id, "decimalchar", decimalChar); 
                    } 
                    else if (type == ValidationDataType.Currency) {
                        string decimalChar = info.CurrencyDecimalSeparator; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "decimalchar", decimalChar);

                        string groupChar = info.CurrencyGroupSeparator;
                        // Map non-break space onto regular space for parsing 
                        if (groupChar[0] == 160)
                            groupChar = " "; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "groupchar", groupChar); 

                        int digits = info.CurrencyDecimalDigits; 
                        AddExpandoAttribute(expandoAttributeWriter, id, "digits", digits.ToString(NumberFormatInfo.InvariantInfo), false);

                        // VSWhidbey 83165
                        int groupSize = GetCurrencyGroupSize(info); 
                        if (groupSize > 0) {
                            AddExpandoAttribute(expandoAttributeWriter, id, "groupsize", groupSize.ToString(NumberFormatInfo.InvariantInfo), false); 
                        } 
                    }
                    else if (type == ValidationDataType.Date) { 
                        AddExpandoAttribute(expandoAttributeWriter, id, "dateorder", GetDateElementOrder(), false);
                        AddExpandoAttribute(expandoAttributeWriter, id, "cutoffyear", CutoffYear.ToString(NumberFormatInfo.InvariantInfo), false);

                        // VSWhidbey 504553: The changes of this bug make client-side script not 
                        // using the century attribute anymore, but still generating it for
                        // backward compatibility with Everett pages. 
                        int currentYear = DateTime.Today.Year; 
                        int century = currentYear - (currentYear % 100);
                        AddExpandoAttribute(expandoAttributeWriter, id, "century", century.ToString(NumberFormatInfo.InvariantInfo), false); 
                    }
                }
            }
        } 

 
 
        /// 
        ///    Check if the text can be converted to the type 
        /// 
        public static bool CanConvert(string text, ValidationDataType type) {
            return CanConvert(text, type, false);
        } 

 
        public static bool CanConvert(string text, ValidationDataType type, bool cultureInvariant) { 
            object value = null;
            return Convert(text, type, cultureInvariant, out value); 
        }


        ///  
        /// 
        ///    Return the order of date elements for the current culture 
        ///  
        protected static string GetDateElementOrder() {
            DateTimeFormatInfo info = DateTimeFormatInfo.CurrentInfo; 
            string shortPattern = info.ShortDatePattern;
            if (shortPattern.IndexOf('y') < shortPattern.IndexOf('M')) {
                return "ymd";
            } 
            else if (shortPattern.IndexOf('M') < shortPattern.IndexOf('d')) {
                return "mdy"; 
            } 
            else {
                return "dmy"; 
            }
        }

        // VSWhidbey 83165 
        private static int GetCurrencyGroupSize(NumberFormatInfo info) {
            int [] groupSizes = info.CurrencyGroupSizes; 
            if (groupSizes != null && groupSizes.Length == 1) { 
                return groupSizes[0];
            } 
            else {
                return -1;
            }
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        protected static int CutoffYear {
            get {
                return DateTimeFormatInfo.CurrentInfo.Calendar.TwoDigitYearMax;
            } 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        protected static int GetFullYear(int shortYear) {
            Debug.Assert(shortYear >= 0 && shortYear < 100);
            return DateTimeFormatInfo.CurrentInfo.Calendar.ToFourDigitYear(shortYear); 
        }
 
 
        /// 
        ///    Try to convert the test into the validation data type 
        /// 
        protected static bool Convert(string text, ValidationDataType type, out object value) {
            return Convert(text, type, false, out value);
        } 

 
        protected static bool Convert(string text, ValidationDataType type, bool cultureInvariant, out object value) { 

            value = null; 
            try {
                switch (type) {
                    case ValidationDataType.String:
                        value = text; 
                        break;
 
                    case ValidationDataType.Integer: 
                        value = Int32.Parse(text, CultureInfo.InvariantCulture);
                        break; 

                    case ValidationDataType.Double: {
                        string cleanInput;
                        if (cultureInvariant) { 
                            cleanInput = ConvertDouble(text, CultureInfo.InvariantCulture.NumberFormat);
                        } 
                        else { 
                            cleanInput = ConvertDouble(text, NumberFormatInfo.CurrentInfo);
                        } 

                        if (cleanInput != null) {
                            value = Double.Parse(cleanInput, CultureInfo.InvariantCulture);
                        } 
                        break;
                    } 
 
                    case ValidationDataType.Date: {
                        if (cultureInvariant) { 
                            value = ConvertDate(text, "ymd");
                        }
                        else {
                            // if the calendar is not gregorian, we should not enable client-side, so just parse it directly: 
                            if (!(DateTimeFormatInfo.CurrentInfo.Calendar.GetType() == typeof(GregorianCalendar))) {
                                value = DateTime.Parse(text, CultureInfo.CurrentCulture); 
                                break; 
                            }
 
                            string dateElementOrder = GetDateElementOrder();
                            value = ConvertDate(text, dateElementOrder);
                        }
                        break; 
                    }
 
                    case ValidationDataType.Currency: { 
                        string cleanInput;
                        if (cultureInvariant) { 
                            cleanInput = ConvertCurrency(text, CultureInfo.InvariantCulture.NumberFormat);
                        }
                        else {
                            cleanInput = ConvertCurrency(text, NumberFormatInfo.CurrentInfo); 
                        }
 
                        if (cleanInput != null) { 
                            value = Decimal.Parse(cleanInput, CultureInfo.InvariantCulture);
                        } 
                        break;
                    }
                }
            } 
            catch {
                value = null; 
            } 
            return (value != null);
        } 

        private static string ConvertCurrency(string text, NumberFormatInfo info) {
            string decimalChar = info.CurrencyDecimalSeparator;
            string groupChar = info.CurrencyGroupSeparator; 

            // VSWhidbey 83165 
            string beginGroupSize, subsequentGroupSize; 
            int groupSize = GetCurrencyGroupSize(info);
            if (groupSize > 0) { 
                string groupSizeText = groupSize.ToString(NumberFormatInfo.InvariantInfo);
                beginGroupSize = "{1," + groupSizeText + "}";
                subsequentGroupSize = "{" + groupSizeText + "}";
            } 
            else {
                beginGroupSize = subsequentGroupSize = "+"; 
            } 

            // Map non-break space onto regular space for parsing 
            if (groupChar[0] == 160)
                groupChar = " ";
            int digits = info.CurrencyDecimalDigits;
            bool hasDigits = (digits > 0); 
            string currencyExpression =
                "^\\s*([-\\+])?((\\d" + beginGroupSize + "(\\" + groupChar + "\\d" + subsequentGroupSize + ")+)|\\d*)" 
                + (hasDigits ? "\\" + decimalChar + "?(\\d{0," + digits.ToString(NumberFormatInfo.InvariantInfo) + "})" : string.Empty) 
                + "\\s*$";
 
            Match m = Regex.Match(text, currencyExpression);
            if (!m.Success) {
                return null;
            } 

            // Make sure there are some valid digits 
            if (m.Groups[2].Length == 0 && hasDigits && m.Groups[5].Length == 0) { 
                return null;
            } 

            return m.Groups[1].Value
                   + m.Groups[2].Value.Replace(groupChar, string.Empty)
                   + ((hasDigits && m.Groups[5].Length > 0) ? "." + m.Groups[5].Value : string.Empty); 
        }
 
        private static string ConvertDouble(string text, NumberFormatInfo info) { 
            // VSWhidbey 83156: If text is empty, it would be default to 0 for
            // backward compatibility reason. 
            if (text.Length == 0) {
                return "0";
            }
 
            string decimalChar = info.NumberDecimalSeparator;
            string doubleExpression = "^\\s*([-\\+])?(\\d*)\\" + decimalChar + "?(\\d*)\\s*$"; 
 
            Match m = Regex.Match(text, doubleExpression);
            if (!m.Success) { 
                return null;
            }

            // Make sure there are some valid digits 
            if (m.Groups[2].Length == 0 && m.Groups[3].Length == 0) {
                return null; 
            } 

            return m.Groups[1].Value 
                   + (m.Groups[2].Length > 0 ? m.Groups[2].Value : "0")
                   + ((m.Groups[3].Length > 0) ? "." + m.Groups[3].Value: string.Empty);
        }
 
        // ***************************************************************************************************************
        // **                                                                                                            ** 
        // ** NOTE: When updating the regular expressions in this method, you must also update the regular expressions   ** 
        // **       in WebUIValidation.js::ValidatorConvert().  The server and client regular expressions must match.    **
        // **                                                                                                            ** 
        // ***************************************************************************************************************
        private static object ConvertDate(string text, string dateElementOrder) {
            // always allow the YMD format, if they specify 4 digits
            string dateYearFirstExpression = "^\\s*((\\d{4})|(\\d{2}))([-/]|\\. ?)(\\d{1,2})\\4(\\d{1,2})\\.?\\s*$"; 
            Match m = Regex.Match(text, dateYearFirstExpression);
            int day, month, year; 
            if (m.Success && (m.Groups[2].Success || dateElementOrder == "ymd")) { 
                day = Int32.Parse(m.Groups[6].Value, CultureInfo.InvariantCulture);
                month = Int32.Parse(m.Groups[5].Value, CultureInfo.InvariantCulture); 
                if (m.Groups[2].Success) {
                    year = Int32.Parse(m.Groups[2].Value, CultureInfo.InvariantCulture);
                }
                else { 
                    year = GetFullYear(Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture));
                } 
            } 
            else {
                if (dateElementOrder == "ymd") { 
                    return null;
                }

                // also check for the year last format 
                string dateYearLastExpression = "^\\s*(\\d{1,2})([-/]|\\. ?)(\\d{1,2})(?:\\s|\\2)((\\d{4})|(\\d{2}))(?:\\s\u0433\\.|\\.)?\\s*$";
                m = Regex.Match(text, dateYearLastExpression); 
                if (!m.Success) { 
                    return null;
                } 
                if (dateElementOrder == "mdy") {
                    day = Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture);
                    month = Int32.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture);
                } 
                else {
                    day = Int32.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture); 
                    month = Int32.Parse(m.Groups[3].Value, CultureInfo.InvariantCulture); 
                }
                if (m.Groups[5].Success) { 
                    year = Int32.Parse(m.Groups[5].Value, CultureInfo.InvariantCulture);
                } else {
                    year = GetFullYear(Int32.Parse(m.Groups[6].Value, CultureInfo.InvariantCulture));
                } 
            }
            return new DateTime(year, month, day); 
        } 

 
        /// 
        ///    Compare two strings using the type and operator
        /// 
        protected static bool Compare(string leftText, string rightText, ValidationCompareOperator op, ValidationDataType type) { 
            return Compare(leftText, false, rightText, false, op, type);
        } 
 

        protected static bool Compare(string leftText, bool cultureInvariantLeftText, 
                                      string rightText, bool cultureInvariantRightText,
                                      ValidationCompareOperator op, ValidationDataType type) {
            object leftObject;
            if (!Convert(leftText, type, cultureInvariantLeftText, out leftObject)) 
                return false;
 
            if (op == ValidationCompareOperator.DataTypeCheck) 
                return true;
 
            object rightObject;
            if (!Convert(rightText, type, cultureInvariantRightText, out rightObject))
                return true;
 
            int compareResult;
            switch (type) { 
                case ValidationDataType.String: 
                    compareResult = String.Compare((string)leftObject, (string) rightObject, false, CultureInfo.CurrentCulture);
                    break; 

                case ValidationDataType.Integer:
                    compareResult = ((int)leftObject).CompareTo(rightObject);
                    break; 

                case ValidationDataType.Double: 
                    compareResult = ((double)leftObject).CompareTo(rightObject); 
                    break;
 
                case ValidationDataType.Date:
                    compareResult = ((DateTime)leftObject).CompareTo(rightObject);
                    break;
 
                case ValidationDataType.Currency:
                    compareResult = ((Decimal)leftObject).CompareTo(rightObject); 
                    break; 

                default: 
                    Debug.Fail("Unknown Type");
                    return true;
            }
 
            switch (op) {
                case ValidationCompareOperator.Equal: 
                    return compareResult == 0; 
                case ValidationCompareOperator.NotEqual:
                    return compareResult != 0; 
                case ValidationCompareOperator.GreaterThan:
                    return compareResult > 0 ;
                case ValidationCompareOperator.GreaterThanEqual:
                    return compareResult >= 0 ; 
                case ValidationCompareOperator.LessThan:
                    return compareResult < 0 ; 
                case ValidationCompareOperator.LessThanEqual: 
                    return compareResult <= 0 ;
                default: 
                    Debug.Fail("Unknown Operator");
                    return true;
            }
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        protected override bool DetermineRenderUplevel() {
            // We don't do client-side validation for dates with non gregorian calendars
            if (Type == ValidationDataType.Date && DateTimeFormatInfo.CurrentInfo.Calendar.GetType() != typeof(GregorianCalendar)) {
                return false; 
            }
            return base.DetermineRenderUplevel(); 
        } 

        internal string ConvertToShortDateString(string text) { 
            // VSWhidbey 83099, 85305, we should ignore error if it happens and
            // leave text as intact when parsing the date.  We assume the caller
            // (validator) is able to handle invalid text itself.
            DateTime date; 
            if (DateTime.TryParse(text, CultureInfo.CurrentCulture, DateTimeStyles.None, out date)) {
                text = date.ToShortDateString(); 
            } 
            return text;
        } 

        internal bool IsInStandardDateFormat(string date) {
            // VSWhidbey 115454: We identify that date string with only numbers
            // and specific punctuation separators is in standard date format. 
            const string standardDateExpression = "^\\s*(\\d+)([-/]|\\. ?)(\\d+)\\2(\\d+)\\s*$";
            return Regex.Match(date, standardDateExpression).Success; 
        } 

        internal string ConvertCultureInvariantToCurrentCultureFormat(string valueInString, 
                                                                      ValidationDataType type) {
            object value;
            Convert(valueInString, type, true, out value);
            if (value is DateTime) { 
                // For Date type we explicitly want the date portion only
                return ((DateTime) value).ToShortDateString(); 
            } 
            else {
                return System.Convert.ToString(value, CultureInfo.CurrentCulture); 
            }
        }
    }
} 

// 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