C#

Int32 _minValue = 0;
Int32 _maxValue = 100;
Int32 trialvalue;

private bool checkInt(object val)
{
    string strval = val.ToString();

    if (Int32.TryParse(strval, out trialvalue))
    {
        // you have an integer

        // in range: good to go
        if (trialvalue >= _minValue && trialvalue <= _maxValue) return true;

        // handle out of range error here
        // ErrorText = outOfRangeErrorText; // define this somewhere
        return false;
    }

    // analyze for other errors
    return false;
}

public override bool Validate(Control control, object value)
{
    if (value == null && !_IsAllowNull)
    {
        ErrorText = "Please provided valid number without a decimal point.";
        return false;
    }

    if (value.ToString().Contains("."))
    {
        ErrorText = "Decimal value is not allowed";
        return false;
    }

    if (!value.IsNumber())
    {
        ErrorText = "Please provided valid number without a decimal point.";
        return false;
    }
    if (value.ToInt() < _minValue || value.ToInt() > _maxValue)
    {
        ErrorText = "Value should not be greater than " + _maxValue + " or less than " + _minValue;
        return false;
    }
    return true;
}

if (value is Int32)
{
   // convert to Int32 from object
   int valasInt32 = Convert.ToInt32(val);

   // check for in range and return bool
   return ?
}

if (value is string)
{
   // process string input
   return ?
}

// if you get here 'value is some other Type than String or Int32: try to Convert to Int32 ?

public sealed class ValidateInteger : ValidationRule
{
    private int _maxValue = int.MaxValue;
    private int _minValue = int.MinValue;
    private bool _IsAllowNull;

    public ValidateInteger(bool isAllowNull = false)
    {
        _IsAllowNull = isAllowNull;
    }

    public ValidateInteger(int min, int max, bool isAllowNull = false)
    {
        _maxValue = max;
        _minValue = min;
        _IsAllowNull = isAllowNull;
    }

    public override bool Validate(Control control, object value)
    {
        if (value == null && !_IsAllowNull)
        {
            ErrorText = "Please provided valid number without a decimal point.";
            return false;
        }

        if (value.ToString().Contains("."))
        {
            ErrorText = "Decimal value is not allowed";
            return false;
        }

        if (!value.IsNumber())
        {
            ErrorText = "Please provided valid number without a decimal point.";
            return false;
        }
        if (value.ToInt() < _minValue || value.ToInt() > _maxValue)
        {
            ErrorText = "Value should not be greater than " + _maxValue + " or less than " + _minValue;
            return false;
        }
        return true;
    }
}

dxValidationProviderMain.SetValidationRule(txt_height, new Validators.ValidateInteger(false));

dxValidationProviderMain.Validate()

• the control variable is never used inside the function.
• Is there a reason to pass value as an object? In addition I would never use a keyword (value) as a variable name. (unless the autofill gave it that name of course)
• I never program multiple exit points in a function, often it is harder to debug. Better to set a boolean and return that at the end. (although that's more a matter of taste)
• Keep the { }. It will be easier to add a statement if a modification is needed.
• int.TryParse is a very good function. I also often use Convert.ToInt32, but make sure you know what it returns in case of null values or invalid integer strings/objects. (read MSDN doc)
• In some countries the decimal sign is not a ".", but a komma ",".
• You don't need _minValue or _maxValue you have int.MinValue and int.MaxValue.
• An object variable has an IsNumber() and ToInt() function? (not in version 4.5)

private int _maxValue = int.MaxValue;
            private int _minValue = int.MinValue;
            private bool _IsAllowNull;

            public ValidateInteger(bool isAlloweNull = true)
            {
                _IsAllowNull = isAlloweNull;
            }

            public ValidateInteger(int min, int max, bool isAlloweNull = false)
            {
                _maxValue = max;
                _minValue = min;
                _IsAllowNull = isAlloweNull;
            }

using System;

class ConsoleApplication
{
    public class ExampleClass
    {
        public int ExId { set; get; }

        public string ExString { set; get; }

        public ExampleClass(int exId, string exString)
        {
            ExId = exId;
            ExString = exString;
        }
    }

    static void Main(string[] args)
    {
        object ec = new ExampleClass(1, "hello world");
        dynamic ec2 = ec;
        Console.WriteLine(ec2.ExString);
        Console.ReadLine();
    }
}

BillWoodruff wrote:

Security reasons ?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

L_001a: ldfld class SpoofTest.ExampleClass SpoofTest.Class1::example
L_001f: isinst SpoofTest.IExample

public Class1()
{
  IExample iexample = example as IExample;
  if (iexample == null)
  {
    System.Diagnostics.Debug.WriteLine("This does not compute");
  }
}

.method public hidebysig specialname rtspecialname instance void .ctor() cil managed
{
    .maxstack 3
    .locals init (
        [0] class SpoofTest.IExample iexample,
        [1] bool CS$4$0000)
    L_0000: ldarg.0
    L_0001: ldc.i4.1
    L_0002: ldstr "Test"
    L_0007: newobj instance void SpoofTest.ExampleClass::.ctor(int32, string)
    L_000c: stfld class SpoofTest.ExampleClass SpoofTest.Class1::example
    L_0011: ldarg.0
    L_0012: call instance void [mscorlib]System.Object::.ctor()
    L_0017: nop
    L_0018: nop
    L_0019: ldarg.0
    L_001a: ldfld class SpoofTest.ExampleClass SpoofTest.Class1::example
    L_001f: isinst SpoofTest.IExample
    L_0024: stloc.0
    L_0025: ldloc.0
    L_0026: ldnull
    L_0027: ceq
    L_0029: ldc.i4.0
    L_002a: ceq
    L_002c: stloc.1
    L_002d: ldloc.1
    L_002e: brtrue.s L_003d
    L_0030: nop
    L_0031: ldstr "This does not compute"
    L_0036: call void [System]System.Diagnostics.Debug::WriteLine(string)
    L_003b: nop
    L_003c: nop
    L_003d: nop
    L_003e: ret
}

.method public hidebysig specialname rtspecialname instance void .ctor() cil managed
{
    .maxstack 3
    .locals init (
        [0] class SpoofTest.IExample iexample,
        [1] bool CS$4$0000)
    L_0000: ldarg.0
    L_0001: ldc.i4.1
    L_0002: ldstr "Test"
    L_0007: newobj instance void SpoofTest.ExampleClass::.ctor(int32, string)
    L_000c: stfld class SpoofTest.ExampleClass SpoofTest.Class1::example
    L_0011: ldarg.0
    L_0012: call instance void [mscorlib]System.Object::.ctor()
    L_0017: nop
    L_0018: nop
    L_0019: ldarg.0
    L_001a: ldfld class SpoofTest.ExampleClass SpoofTest.Class1::example
    L_001f: stloc.0
    L_0020: ldloc.0
    L_0021: ldnull
    L_0022: ceq
    L_0024: ldc.i4.0
    L_0025: ceq
    L_0027: stloc.1
    L_0028: ldloc.1
    L_0029: brtrue.s L_0038
    L_002b: nop
    L_002c: ldstr "This does not compute"
    L_0031: call void [System]System.Diagnostics.Debug::WriteLine(string)
    L_0036: nop
    L_0037: nop
    L_0038: nop
    L_0039: ret
}