Hello friends,
I wrote a simple class for string validation and now I want to share with you.

The class contains:

- Constructor(s)
public Validator()
public Validator(string text)

- Properties
private string strText = string.Empty;

- Method(s)
public bool isNullOrEmpty()
public bool isNullOrEmpty(string str)
public bool isLengthMax(int maxLength)
public bool isLengthMin(int minLength)
public bool isLength(int min, int max)
public bool isLengthMax(string str, int maxLength)
public bool isLengthMin(string str, int minLength)
public bool isLength(string str, int min, int max)
public bool isNumber()
public bool isAlpha()
public bool isAlpha(string str)
public bool isAlphaNumeric()
public bool isAlphaNumeric(string str)
public bool isMailValid()
public bool isMailValid(string mail)
public bool isLower()
public bool isLower(string str)
public bool isUpper()
public bool isUpper(string str)

NOTE: The UTF8 strings are not supported.

External link(s):
http://msdn.microsoft.com/en-us/library/system.configuration.stringvalidator.aspx
If you have any comment, suggestion...
Thanks, SkyDriver

Edited 6 Years Ago by Krstevski: n/a

using System;
using System.Collections.Generic;
using System.Linq; /*** dotNet version ***/
using System.Text;

using System.Text.RegularExpressions;

/*
 * @Name:           ValidatorLib
 * @Description:    String validation
 * @Author:         Damjan Krstevski - SkyDriver
 * @Date:           20.11.2010
 * @License:        Freeware, you can use, edit, copy, redistribute...
 * @FeedBack:       krstevsky[at]gmail[dot]com
 */

namespace ValidatorLib
{
    /// <summary>
    /// Class for validation of the string
    /// </summary>
    class Validator
    {

        #region Class variable(s)
        /// <summary>
        /// Class value
        /// </summary>
        private string strText = string.Empty;
        #endregion


        #region Constructor(s)
        /// <summary>
        /// Default constructor
        /// </summary>
        public Validator()
        {

        }


        /// <summary>
        /// Other constructor with text value
        /// </summary>
        /// <param name="text">String, the string for validation</param>
        public Validator(string text)
        {
            this.strText = text;
        }
        #endregion


        #region SET and GET methods
        /// <summary>
        /// Set or Get the string value
        /// </summary>
        public string text
        {
            get { return this.strText; }
            set { this.strText = value; }
        }
        #endregion


        #region Function: isNullOrEmpty
        /// <summary>
        /// Check if the string is null or empty
        /// </summary>
        /// <returns>Bool, true if the string is null or empty</returns>
        public bool isNullOrEmpty()
        {
            return string.IsNullOrEmpty(this.strText);
        }


        /// <summary>
        /// Check if the string is null or empty
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <returns>Bool, true if the string is null or empty</returns>
        public bool isNullOrEmpty(string str)
        {
            return string.IsNullOrEmpty(str);
        }
        #endregion


        #region Function: Length validation
        /// <summary>
        /// Check string length (maximum length)
        /// </summary>
        /// <param name="maxLength">Int, the maximum allowed length</param>
        /// <returns>Bool, true if the string length is smallest or equal with the maximum allowed length</returns>
        public bool isLengthMax(int maxLength)
        {
            return this.strText.Length <= maxLength ? true : false;
        }


        /// <summary>
        /// Check string length (minimum length)
        /// </summary>
        /// <param name="minLength">Int, the minimum allowed length</param>
        /// <returns>Bool, true if the string length is biggest or equal with the minimum allowed length</returns>
        public bool isLengthMin(int minLength)
        {
            return this.strText.Length >= minLength ? true : false;
        }


        /// <summary>
        /// Check string length according given length range (minimum & maximum)
        /// </summary>
        /// <param name="min">Int, minimum allowed length</param>
        /// <param name="max">Int, maximum allowed length</param>
        /// <returns>Bool, true if the string length is between the given length range</returns>
        public bool isLength(int min, int max)
        {
            return this.strText.Length >= min && this.strText.Length <= max ? true : false;
        }


        /// <summary>
        /// Check the string length (maximum length)
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <param name="maxLength">Int, maximum allowed length</param>
        /// <returns>Bool, true if the string length is smallest or equal with the allowed length</returns>
        public bool isLengthMax(string str, int maxLength)
        {
            return str.Length <= maxLength ? true : false;
        }


        /// <summary>
        /// Check the string length (minimum length)
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <param name="minLength">Int, the minimum allowed length</param>
        /// <returns>Bool, true if the string length is biggest or equal with the allowed length</returns>
        public bool isLengthMin(string str, int minLength)
        {
            return str.Length >= minLength ? true : false;
        }


        /// <summary>
        /// Check the string length according given length range (minimum & maximum)
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <param name="min">Int, minimum allowed length</param>
        /// <param name="max">Int, maximum allowed length</param>
        /// <returns>Bool, true if the string length is between given length range</returns>
        public bool isLength(string str, int min, int max)
        {
            return str.Length >= min && str.Length <= max ? true : false;
        }
        #endregion


        #region Functions: is number, alpha, alpha-numeric...
        /// <summary>
        /// Check the string if is a number
        /// </summary>
        /// <returns>Bool, true if the string is a number</returns>
        public bool isNumber()
        {
            int tmp_n = 0;
            return int.TryParse(this.strText, out tmp_n);
        }


        /// <summary>
        /// Check if the string contains only alpha character(s)
        /// </summary>
        /// <returns>Bool, true if the string contains only alpha characters</returns>
        public bool isAlpha()
        {
            Regex r = new Regex(@"[^a-zA-Z]");
            return !r.IsMatch(this.strText);
        }


        /// <summary>
        /// Check if the string contains only alpha character(s)
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <returns>Bool, true if the string contains only alpha characters</returns>
        public bool isAlpha(string str)
        {
            Regex r = new Regex(@"[^a-zA-Z]");
            return !r.IsMatch(str);
        }


        /// <summary>
        /// Check if the string contains only alpha-numeric characters
        /// </summary>
        /// <returns>Bool, true if the string contains only alpha-numeric characters</returns>
        public bool isAlphaNumeric()
        {
            Regex r = new Regex(@"[^a-zA-Z0-9]");
            return !r.IsMatch(this.strText); 
        }


        /// <summary>
        /// Check if the string contains only alpha-numeric characters
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <returns>Bool, if the string contains only alpha-numeric characters</returns>
        public bool isAlphaNumeric(string str)
        {
            Regex r = new Regex(@"[^a-zA-Z0-9]");
            return !r.IsMatch(str);
        }
        #endregion


        #region Function: Mail validation
        /// <summary>
        /// Check if the mail is valid
        /// </summary>
        /// <returns>Bool, true if the mail address is valid</returns>
        public bool isMailValid()
        {
            string pattern = @"^[-a-zA-Z0-9][-.a-zA-Z0-9]*@[-.a-zA-Z0-9]+(\.[-.a-zA-Z0-9]+)*\.
                (com|edu|info|gov|int|mil|net|org|biz|name|museum|coop|aero|pro|tv|[a-zA-Z]{2})$";
            Regex r = new Regex(pattern, RegexOptions.IgnorePatternWhitespace);
            return r.IsMatch(this.strText);
        }


        /// <summary>
        /// Check if the mail is valid
        /// </summary>
        /// <param name="mail">String, the mail address for validation</param>
        /// <returns>Bool, true if the mail address is valid</returns>
        public bool isMailValid(string mail)
        {
            string pattern = @"^[-a-zA-Z0-9][-.a-zA-Z0-9]*@[-.a-zA-Z0-9]+(\.[-.a-zA-Z0-9]+)*\.
                (com|edu|info|gov|int|mil|net|org|biz|name|museum|coop|aero|pro|tv|[a-zA-Z]{2})$";
            Regex check = new Regex(pattern, RegexOptions.IgnorePatternWhitespace);
            return check.IsMatch(mail);
        }
        #endregion


        #region Functions: is lower, upper...
        /// <summary>
        /// Check if the string contains only lower characters
        /// </summary>
        /// <returns>Bool, true if the string contains only lower charaters</returns>
        public bool isLower()
        {
            Regex r = new Regex(@"[^a-z]$");
            return !r.IsMatch(this.strText);
        }


        /// <summary>
        /// Check if the string contains only lower characters
        /// </summary>
        /// <param name="str">String, string for validation</param>
        /// <returns>Bool, true if the string contains only lower charaters</returns>
        public bool isLower(string str)
        {
            Regex r = new Regex(@"[^a-z]$");
            return !r.IsMatch(str);
        }


        /// <summary>
        /// Check if the string contains only upper characters
        /// </summary>
        /// <returns>Bool, true if the string contains only upper characters</returns>
        public bool isUpper()
        {
            Regex r = new Regex(@"[^A-Z]$");
            return !r.IsMatch(this.strText);
        }


        /// <summary>
        /// Check if the string contains only upper characters
        /// </summary>
        /// <param name="str">String, the string for validation</param>
        /// <returns>Bool, true if the string contains only upper characters</returns>
        public bool isUpper(string str)
        {
            Regex r = new Regex(@"[^A-Z]$");
            return !r.IsMatch(str);
        }
        #endregion


    }
}

Your isNumber fails on 34.2 (or any decimal number) and longs.

In the various is...() methods, why do you set the regex for the opposite of what you want, then negate the result? Why not just set it to what you want and return the result?

What utility does this really provide for length checking? First I have to create a validator, then call a method on the validator. How is this easier than just using String.Length?

Wouldn't these be better as extension methods?