NewRuleEngineTest | C# Online Compiler

NewRuleEngineTest by Milad D Zand

using System;
using System.Text.RegularExpressions;

    public class BaseRule
    {
        public bool IsValid { get; set; }
        public bool IsRequired { get; set; }

        public BaseRule()
        {
            IsValid = false;
            IsValid = false;
        }

        public void Test()
        {
            var age = 25;
            var gender = true;

            //assum that age must be in range 30, 40 for male and in range 35, 45 for female
            var baseRule = new BaseRule();
            baseRule.OneWayComparisonForTwoValues(
                baseRule.IsBetweenTwoValues,
                baseRule.IsBetweenTwoValues,
                age, 
                30, 
                40,
                20,
                30);
        }

        public bool IsNull<T>(T value)
        {
            return value == null;
        }

        public bool IsNotNull<T>(T value)
        {
            return value != null;
        }

        public bool IsBetweenTwoValues(int currentValue, int value1, int value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);

            return result;
        }

        public bool IsBetweenTwoValues(long currentValue, long value1, long value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);

            return result;
        }

        public bool IsBetweenTwoValues(double currentValue, double value1, double value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);

            return result;
        }

        public bool IsBetweenTwoValues(DateTime currentValue, DateTime value1, DateTime value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);

            return result;
        }

        public bool IsGreaterThan(int currrentValue, int value)
        {
            var result = (currrentValue > value);

            return result;
        }

        public bool IsGreaterThan(long currrentValue, long value)
        {
            var result = (currrentValue > value);

            return result;
        }

        public bool IsGreaterThan(double currrentValue, double value)
        {
            var result = (currrentValue > value);

            return result;
        }

        public bool IsGreaterThan(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue > value);

            return result;
        }

        public bool IsGreaterThan<T>(T currrentValue, T value)
        {
            var t = currrentValue.GetType();
            var result = false;
            dynamic currrentVal;
            dynamic val;

            switch (Type.GetTypeCode(t))
            {
                case TypeCode.Boolean:
                    currrentVal = Convert.ToBoolean(currrentValue);
                    val = Convert.ToBoolean(value);
                    result = currrentVal == true && val == false;
                    break;

                case TypeCode.Byte:
                    currrentVal = Convert.ToByte(currrentValue);
                    val = Convert.ToByte(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Char:
                    currrentVal = Convert.ToChar(currrentValue);
                    val = Convert.ToChar(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.DBNull:
                    break;

                case TypeCode.DateTime:
                    currrentVal = Convert.ToDateTime(currrentValue);
                    val = Convert.ToDateTime(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Decimal:
                    currrentVal = Convert.ToDecimal(currrentValue);
                    val = Convert.ToDecimal(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Double:
                    currrentVal = Convert.ToDouble(currrentValue);
                    val = Convert.ToDouble(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Empty:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;

                case TypeCode.Int16:
                    currrentVal = Convert.ToInt16(currrentValue);
                    val = Convert.ToInt16(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Int32:
                    currrentVal = Convert.ToInt32(currrentValue);
                    val = Convert.ToInt32(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Int64:
                    currrentVal = Convert.ToInt64(currrentValue);
                    val = Convert.ToInt64(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Object:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;

                case TypeCode.SByte:
                    currrentVal = Convert.ToSByte(currrentValue);
                    val = Convert.ToSByte(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.Single:
                    currrentVal = Convert.ToSingle(currrentValue);
                    val = Convert.ToSingle(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.String:
                    currrentVal = Convert.ToString(currrentValue);
                    val = Convert.ToString(value);
                    result = currrentVal.Length > val.Length;
                    break;

                case TypeCode.UInt16:
                    currrentVal = Convert.ToUInt16(currrentValue);
                    val = Convert.ToUInt16(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.UInt32:
                    currrentVal = Convert.ToUInt32(currrentValue);
                    val = Convert.ToUInt32(value);
                    result = currrentVal > val;
                    break;

                case TypeCode.UInt64:
                    currrentVal = Convert.ToUInt64(currrentValue);
                    val = Convert.ToUInt64(value);
                    result = currrentVal > val;
                    break;

                default:
                    throw new Exception("Exception, Invalid argument type exception.");
            }

            return result;
        }

        public bool IsGreaterThanOrEqual(int currrentValue, int value)
        {
            var result = (currrentValue >= value);

            return result;
        }

        public bool IsGreaterThanOrEqual(long currrentValue, long value)
        {
            var result = (currrentValue >= value);

            return result;
        }

        public bool IsGreaterThanOrEqual(double currrentValue, double value)
        {
            var result = (currrentValue >= value);

            return result;
        }

        public bool IsGreaterThanOrEqual(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue >= value);

            return result;
        }

        public bool IsLessThan(int currrentValue, int value)
        {
            var result = (currrentValue < value);

            return result;
        }

        public bool IsLessThan(long currrentValue, long value)
        {
            var result = (currrentValue < value);

            return result;
        }

        public bool IsLessThan(double currrentValue, double value)
        {
            var result = (currrentValue < value);

            return result;
        }

        public bool IsLessThan(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue < value);

            return result;
        }

        public bool IsLessThanOrEqual(int currrentValue, int value)
        {
            var result = (currrentValue <= value);

            return result;
        }

        public bool IsLessThanOrEqual(long currrentValue, long value)
        {
            var result = (currrentValue <= value);

            return result;
        }

        public bool IsLessThanOrEqual(double currrentValue, double value)
        {
            var result = (currrentValue <= value);

            return result;
        }

        public bool IsLessThanOrEqual(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue <= value);

            return result;
        }

        public bool IsMatch(string currentValue, string pattern)
        {
            var result = false;

            var r = new Regex(pattern);
            result = r.IsMatch(currentValue);

            return result;
        }

        public bool IsGreaterThanNow(DateTime currrentValue)
        {
            var result = currrentValue > DateTime.Now;

            return result;
        }

        public bool IsNotFutureDate(DateTime currrentValue)
        {
            var result = currrentValue <= DateTime.Now;

            return result;
        }

        public bool IsEqual(int currrentValue, int value)
        {
            var result = currrentValue == value;

            return result;
        }

        public bool IsEqual(long currrentValue, long value)
        {
            var result = currrentValue == value;

            return result;
        }

        public bool IsEqual(double currrentValue, double value)
        {
            var result = Math.Abs(currrentValue - value) < 0.0000001;

            return result;
        }

        public bool IsDateTimeEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue == value;

            return result;
        }

        public bool IsDateEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue.Date == value.Date;

            return result;
        }

        public bool IsTimeEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue.TimeOfDay == value.TimeOfDay;

            return result;
        }

        public bool IsEqual<T>(T currrentValue, T value)
        {
            var t = currrentValue.GetType();
            var result = false;
            dynamic currrentVal;
            dynamic val;

            switch (Type.GetTypeCode(t))
            {
                case TypeCode.Boolean:
                    currrentVal = Convert.ToBoolean(currrentValue);
                    val = Convert.ToBoolean(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Byte:
                    currrentVal = Convert.ToByte(currrentValue);
                    val = Convert.ToByte(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Char:
                    currrentVal = Convert.ToChar(currrentValue);
                    val = Convert.ToChar(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.DBNull:
                    break;

                case TypeCode.DateTime:
                    currrentVal = Convert.ToDateTime(currrentValue);
                    val = Convert.ToDateTime(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Decimal:
                    currrentVal = Convert.ToDecimal(currrentValue);
                    val = Convert.ToDecimal(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Double:
                    currrentVal = Convert.ToDouble(currrentValue);
                    val = Convert.ToDouble(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Empty:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;

                case TypeCode.Int16:
                    currrentVal = Convert.ToInt16(currrentValue);
                    val = Convert.ToInt16(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Int32:
                    currrentVal = Convert.ToInt32(currrentValue);
                    val = Convert.ToInt32(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Int64:
                    currrentVal = Convert.ToInt64(currrentValue);
                    val = Convert.ToInt64(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Object:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;

                case TypeCode.SByte:
                    currrentVal = Convert.ToSByte(currrentValue);
                    val = Convert.ToSByte(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.Single:
                    currrentVal = Convert.ToSingle(currrentValue);
                    val = Convert.ToSingle(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.String:
                    currrentVal = Convert.ToString(currrentValue);
                    val = Convert.ToString(value);
                    result = currrentVal.Length == val.Length;
                    break;

                case TypeCode.UInt16:
                    currrentVal = Convert.ToUInt16(currrentValue);
                    val = Convert.ToUInt16(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.UInt32:
                    currrentVal = Convert.ToUInt32(currrentValue);
                    val = Convert.ToUInt32(value);
                    result = currrentVal == val;
                    break;

                case TypeCode.UInt64:
                    currrentVal = Convert.ToUInt64(currrentValue);
                    val = Convert.ToUInt64(value);
                    result = currrentVal == val;
                    break;

                default:
                    throw new Exception("Exception, Invalid argument type exception.");
            }

            return result;
        }

        #region TwoWayComparison
        public bool TwoWayComparisonForOneValues(
            Func<int, int, bool> ruleLeft, 
            Func<int, int, bool> ruleRight,
            int currentValue, 
            int ruleLeftValue,
            int ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool TwoWayComparisonForOneValues(
            Func<long, long, bool> ruleLeft,
            Func<long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue,
            long ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool TwoWayComparisonForOneValues(
            Func<double, double, bool> ruleLeft,
            Func<double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue,
            double ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool TwoWayComparisonForOneValues(
            Func<DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue,
            DateTime ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool TwoWayComparisonForOneValues<T>(
            Func<T, T, bool> ruleLeft,
            Func<T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue,
            T ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool TwoWayComparisonForTwoValues(
            Func<int, int, int, bool> ruleLeft,
            Func<int, int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue1,
            int ruleLeftvalue2,
            int ruleRightValue1,
            int ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool TwoWayComparisonForTwoValues(
            Func<long, long, long, bool> ruleLeft,
            Func<long, long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue1,
            long ruleLeftvalue2,
            long ruleRightValue1,
            long ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool TwoWayComparisonForTwoValues(
            Func<double, double, double, bool> ruleLeft,
            Func<double, double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue1,
            double ruleLeftvalue2,
            double ruleRightValue1,
            double ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool TwoWayComparisonForTwoValues(
            Func<DateTime, DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue1,
            DateTime ruleLeftvalue2,
            DateTime ruleRightValue1,
            DateTime ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool TwoWayComparisonForTwoValues<T>(
            Func<T, T, T, bool> ruleLeft,
            Func<T, T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue1,
            T ruleLeftvalue2,
            T ruleRightValue1,
            T ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        #endregion

        #region OneWayComparison
        public bool OneWayComparisonForOneValues(
            Func<int, int, bool> ruleLeft,
            Func<int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue,
            int ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool OneWayComparisonForOneValues(
            Func<long, long, bool> ruleLeft,
            Func<long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue,
            long ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool OneWayComparisonForOneValues(
            Func<double, double, bool> ruleLeft,
            Func<double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue,
            double ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool OneWayComparisonForOneValues(
            Func<DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue,
            DateTime ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);

            return result;
        }

        public bool OneWayComparisonForOneValues<T>(
            Func<T, T, bool> ruleLeft,
            Func<T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue,
            T ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);

            return result;
        }

        //Two Values means that the called functions has two arguments
        public bool OneWayComparisonForTwoValues(
            Func<int, int, int, bool> ruleLeft,
            Func<int, int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue1,
            int ruleLeftvalue2,
            int ruleRightValue1,
            int ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool OneWayComparisonForTwoValues(
            Func<long, long, long, bool> ruleLeft,
            Func<long, long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue1,
            long ruleLeftvalue2,
            long ruleRightValue1,
            long ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool OneWayComparisonForTwoValues(
            Func<double, double, double, bool> ruleLeft,
            Func<double, double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue1,
            double ruleLeftvalue2,
            double ruleRightValue1,
            double ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool OneWayComparisonForTwoValues(
            Func<DateTime, DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue1,
            DateTime ruleLeftvalue2,
            DateTime ruleRightValue1,
            DateTime ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        public bool OneWayComparisonForTwoValues<T>(
            Func<T, T, T, bool> ruleLeft,
            Func<T, T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue1,
            T ruleLeftvalue2,
            T ruleRightValue1,
            T ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);

            return result;
        }

        #endregion

    }
					
public class Program
{
	
	public static void Main()
	{
		var age = 20;
		var gender = true;
		
		//assum that age must be in range 30, 40 for male and in range 35, 45 for female
		var baseRule = new BaseRule();
		
		var result = (baseRule.IsBetweenTwoValues(age, 30, 40) && baseRule.IsEqual(gender, true)) || ((baseRule.IsBetweenTwoValues(age, 20, 30) && baseRule.IsEqual(gender, false)));
		
		var result2 = 
			baseRule.OneWayComparisonForTwoValues(
                baseRule.IsBetweenTwoValues,
                baseRule.IsBetweenTwoValues,
                age, 
                30, 
                40,
                20,
                30);

		var result3 = baseRule.OneWayComparisonForOneValues(
                baseRule.IsGreaterThan,
                baseRule.IsLessThan,
                age, 
                15, 
                40);	
		
		var result4 = baseRule.TwoWayComparisonForOneValues(
                baseRule.IsGreaterThan,
                baseRule.IsLessThanOrEqual,
                age, 
                15, 
                18);	
		
		
		Console.WriteLine("Result: " + result);
		Console.WriteLine("Result: " + result2);
		Console.WriteLine("Result: " + result3);
		Console.WriteLine("Result: " + result4);
		
	}
}

​x
 
using System;
using System.Text.RegularExpressions;
​
    public class BaseRule
    {
        public bool IsValid { get; set; }
        public bool IsRequired { get; set; }
​
        public BaseRule()
        {
            IsValid = false;
            IsValid = false;
        }
​
        public void Test()
        {
            var age = 25;
            var gender = true;
​
            //assum that age must be in range 30, 40 for male and in range 35, 45 for female
            var baseRule = new BaseRule();
            baseRule.OneWayComparisonForTwoValues(
                baseRule.IsBetweenTwoValues,
                baseRule.IsBetweenTwoValues,
                age, 
                30, 
                40,
                20,
                30);
        }
​
        public bool IsNull<T>(T value)
        {
            return value == null;
        }
​
        public bool IsNotNull<T>(T value)
        {
            return value != null;
        }
​
        public bool IsBetweenTwoValues(int currentValue, int value1, int value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);
​
            return result;
        }
​
        public bool IsBetweenTwoValues(long currentValue, long value1, long value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);
​
            return result;
        }
​
        public bool IsBetweenTwoValues(double currentValue, double value1, double value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);
​
            return result;
        }
​
        public bool IsBetweenTwoValues(DateTime currentValue, DateTime value1, DateTime value2)
        {
            var result = (value1 <= currentValue && currentValue <= value2);
​
            return result;
        }
​
        public bool IsGreaterThan(int currrentValue, int value)
        {
            var result = (currrentValue > value);
​
            return result;
        }
​
        public bool IsGreaterThan(long currrentValue, long value)
        {
            var result = (currrentValue > value);
​
            return result;
        }
​
        public bool IsGreaterThan(double currrentValue, double value)
        {
            var result = (currrentValue > value);
​
            return result;
        }
​
        public bool IsGreaterThan(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue > value);
​
            return result;
        }
​
        public bool IsGreaterThan<T>(T currrentValue, T value)
        {
            var t = currrentValue.GetType();
            var result = false;
            dynamic currrentVal;
            dynamic val;
​
            switch (Type.GetTypeCode(t))
            {
                case TypeCode.Boolean:
                    currrentVal = Convert.ToBoolean(currrentValue);
                    val = Convert.ToBoolean(value);
                    result = currrentVal == true && val == false;
                    break;
​
                case TypeCode.Byte:
                    currrentVal = Convert.ToByte(currrentValue);
                    val = Convert.ToByte(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Char:
                    currrentVal = Convert.ToChar(currrentValue);
                    val = Convert.ToChar(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.DBNull:
                    break;
​
                case TypeCode.DateTime:
                    currrentVal = Convert.ToDateTime(currrentValue);
                    val = Convert.ToDateTime(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Decimal:
                    currrentVal = Convert.ToDecimal(currrentValue);
                    val = Convert.ToDecimal(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Double:
                    currrentVal = Convert.ToDouble(currrentValue);
                    val = Convert.ToDouble(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Empty:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;
​
                case TypeCode.Int16:
                    currrentVal = Convert.ToInt16(currrentValue);
                    val = Convert.ToInt16(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Int32:
                    currrentVal = Convert.ToInt32(currrentValue);
                    val = Convert.ToInt32(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Int64:
                    currrentVal = Convert.ToInt64(currrentValue);
                    val = Convert.ToInt64(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Object:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;
​
                case TypeCode.SByte:
                    currrentVal = Convert.ToSByte(currrentValue);
                    val = Convert.ToSByte(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.Single:
                    currrentVal = Convert.ToSingle(currrentValue);
                    val = Convert.ToSingle(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.String:
                    currrentVal = Convert.ToString(currrentValue);
                    val = Convert.ToString(value);
                    result = currrentVal.Length > val.Length;
                    break;
​
                case TypeCode.UInt16:
                    currrentVal = Convert.ToUInt16(currrentValue);
                    val = Convert.ToUInt16(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.UInt32:
                    currrentVal = Convert.ToUInt32(currrentValue);
                    val = Convert.ToUInt32(value);
                    result = currrentVal > val;
                    break;
​
                case TypeCode.UInt64:
                    currrentVal = Convert.ToUInt64(currrentValue);
                    val = Convert.ToUInt64(value);
                    result = currrentVal > val;
                    break;
​
                default:
                    throw new Exception("Exception, Invalid argument type exception.");
            }
​
            return result;
        }
​
        public bool IsGreaterThanOrEqual(int currrentValue, int value)
        {
            var result = (currrentValue >= value);
​
            return result;
        }
​
        public bool IsGreaterThanOrEqual(long currrentValue, long value)
        {
            var result = (currrentValue >= value);
​
            return result;
        }
​
        public bool IsGreaterThanOrEqual(double currrentValue, double value)
        {
            var result = (currrentValue >= value);
​
            return result;
        }
​
        public bool IsGreaterThanOrEqual(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue >= value);
​
            return result;
        }
​
        public bool IsLessThan(int currrentValue, int value)
        {
            var result = (currrentValue < value);
​
            return result;
        }
​
        public bool IsLessThan(long currrentValue, long value)
        {
            var result = (currrentValue < value);
​
            return result;
        }
​
        public bool IsLessThan(double currrentValue, double value)
        {
            var result = (currrentValue < value);
​
            return result;
        }
​
        public bool IsLessThan(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue < value);
​
            return result;
        }
​
        public bool IsLessThanOrEqual(int currrentValue, int value)
        {
            var result = (currrentValue <= value);
​
            return result;
        }
​
        public bool IsLessThanOrEqual(long currrentValue, long value)
        {
            var result = (currrentValue <= value);
​
            return result;
        }
​
        public bool IsLessThanOrEqual(double currrentValue, double value)
        {
            var result = (currrentValue <= value);
​
            return result;
        }
​
        public bool IsLessThanOrEqual(DateTime currrentValue, DateTime value)
        {
            var result = (currrentValue <= value);
​
            return result;
        }
​
        public bool IsMatch(string currentValue, string pattern)
        {
            var result = false;
​
            var r = new Regex(pattern);
            result = r.IsMatch(currentValue);
​
            return result;
        }
​
        public bool IsGreaterThanNow(DateTime currrentValue)
        {
            var result = currrentValue > DateTime.Now;
​
            return result;
        }
​
        public bool IsNotFutureDate(DateTime currrentValue)
        {
            var result = currrentValue <= DateTime.Now;
​
            return result;
        }
​
        public bool IsEqual(int currrentValue, int value)
        {
            var result = currrentValue == value;
​
            return result;
        }
​
        public bool IsEqual(long currrentValue, long value)
        {
            var result = currrentValue == value;
​
            return result;
        }
​
        public bool IsEqual(double currrentValue, double value)
        {
            var result = Math.Abs(currrentValue - value) < 0.0000001;
​
            return result;
        }
​
        public bool IsDateTimeEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue == value;
​
            return result;
        }
​
        public bool IsDateEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue.Date == value.Date;
​
            return result;
        }
​
        public bool IsTimeEqual(DateTime currrentValue, DateTime value)
        {
            var result = currrentValue.TimeOfDay == value.TimeOfDay;
​
            return result;
        }
​
        public bool IsEqual<T>(T currrentValue, T value)
        {
            var t = currrentValue.GetType();
            var result = false;
            dynamic currrentVal;
            dynamic val;
​
            switch (Type.GetTypeCode(t))
            {
                case TypeCode.Boolean:
                    currrentVal = Convert.ToBoolean(currrentValue);
                    val = Convert.ToBoolean(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Byte:
                    currrentVal = Convert.ToByte(currrentValue);
                    val = Convert.ToByte(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Char:
                    currrentVal = Convert.ToChar(currrentValue);
                    val = Convert.ToChar(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.DBNull:
                    break;
​
                case TypeCode.DateTime:
                    currrentVal = Convert.ToDateTime(currrentValue);
                    val = Convert.ToDateTime(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Decimal:
                    currrentVal = Convert.ToDecimal(currrentValue);
                    val = Convert.ToDecimal(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Double:
                    currrentVal = Convert.ToDouble(currrentValue);
                    val = Convert.ToDouble(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Empty:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;
​
                case TypeCode.Int16:
                    currrentVal = Convert.ToInt16(currrentValue);
                    val = Convert.ToInt16(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Int32:
                    currrentVal = Convert.ToInt32(currrentValue);
                    val = Convert.ToInt32(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Int64:
                    currrentVal = Convert.ToInt64(currrentValue);
                    val = Convert.ToInt64(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Object:
                    throw new Exception("Exception, Invalid argument type exception.");
                //break;
​
                case TypeCode.SByte:
                    currrentVal = Convert.ToSByte(currrentValue);
                    val = Convert.ToSByte(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.Single:
                    currrentVal = Convert.ToSingle(currrentValue);
                    val = Convert.ToSingle(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.String:
                    currrentVal = Convert.ToString(currrentValue);
                    val = Convert.ToString(value);
                    result = currrentVal.Length == val.Length;
                    break;
​
                case TypeCode.UInt16:
                    currrentVal = Convert.ToUInt16(currrentValue);
                    val = Convert.ToUInt16(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.UInt32:
                    currrentVal = Convert.ToUInt32(currrentValue);
                    val = Convert.ToUInt32(value);
                    result = currrentVal == val;
                    break;
​
                case TypeCode.UInt64:
                    currrentVal = Convert.ToUInt64(currrentValue);
                    val = Convert.ToUInt64(value);
                    result = currrentVal == val;
                    break;
​
                default:
                    throw new Exception("Exception, Invalid argument type exception.");
            }
​
            return result;
        }
​
        #region TwoWayComparison
        public bool TwoWayComparisonForOneValues(
            Func<int, int, bool> ruleLeft, 
            Func<int, int, bool> ruleRight,
            int currentValue, 
            int ruleLeftValue,
            int ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool TwoWayComparisonForOneValues(
            Func<long, long, bool> ruleLeft,
            Func<long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue,
            long ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool TwoWayComparisonForOneValues(
            Func<double, double, bool> ruleLeft,
            Func<double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue,
            double ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool TwoWayComparisonForOneValues(
            Func<DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue,
            DateTime ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool TwoWayComparisonForOneValues<T>(
            Func<T, T, bool> ruleLeft,
            Func<T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue,
            T ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) && ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool TwoWayComparisonForTwoValues(
            Func<int, int, int, bool> ruleLeft,
            Func<int, int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue1,
            int ruleLeftvalue2,
            int ruleRightValue1,
            int ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool TwoWayComparisonForTwoValues(
            Func<long, long, long, bool> ruleLeft,
            Func<long, long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue1,
            long ruleLeftvalue2,
            long ruleRightValue1,
            long ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool TwoWayComparisonForTwoValues(
            Func<double, double, double, bool> ruleLeft,
            Func<double, double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue1,
            double ruleLeftvalue2,
            double ruleRightValue1,
            double ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool TwoWayComparisonForTwoValues(
            Func<DateTime, DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue1,
            DateTime ruleLeftvalue2,
            DateTime ruleRightValue1,
            DateTime ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool TwoWayComparisonForTwoValues<T>(
            Func<T, T, T, bool> ruleLeft,
            Func<T, T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue1,
            T ruleLeftvalue2,
            T ruleRightValue1,
            T ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) &&
                         ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        #endregion
​
        #region OneWayComparison
        public bool OneWayComparisonForOneValues(
            Func<int, int, bool> ruleLeft,
            Func<int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue,
            int ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool OneWayComparisonForOneValues(
            Func<long, long, bool> ruleLeft,
            Func<long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue,
            long ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool OneWayComparisonForOneValues(
            Func<double, double, bool> ruleLeft,
            Func<double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue,
            double ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool OneWayComparisonForOneValues(
            Func<DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue,
            DateTime ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        public bool OneWayComparisonForOneValues<T>(
            Func<T, T, bool> ruleLeft,
            Func<T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue,
            T ruleRightValue)
        {
            var result = ruleLeft(currentValue, ruleLeftValue) || ruleRight(currentValue, ruleRightValue);
​
            return result;
        }
​
        //Two Values means that the called functions has two arguments
        public bool OneWayComparisonForTwoValues(
            Func<int, int, int, bool> ruleLeft,
            Func<int, int, int, bool> ruleRight,
            int currentValue,
            int ruleLeftValue1,
            int ruleLeftvalue2,
            int ruleRightValue1,
            int ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool OneWayComparisonForTwoValues(
            Func<long, long, long, bool> ruleLeft,
            Func<long, long, long, bool> ruleRight,
            long currentValue,
            long ruleLeftValue1,
            long ruleLeftvalue2,
            long ruleRightValue1,
            long ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool OneWayComparisonForTwoValues(
            Func<double, double, double, bool> ruleLeft,
            Func<double, double, double, bool> ruleRight,
            double currentValue,
            double ruleLeftValue1,
            double ruleLeftvalue2,
            double ruleRightValue1,
            double ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool OneWayComparisonForTwoValues(
            Func<DateTime, DateTime, DateTime, bool> ruleLeft,
            Func<DateTime, DateTime, DateTime, bool> ruleRight,
            DateTime currentValue,
            DateTime ruleLeftValue1,
            DateTime ruleLeftvalue2,
            DateTime ruleRightValue1,
            DateTime ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        public bool OneWayComparisonForTwoValues<T>(
            Func<T, T, T, bool> ruleLeft,
            Func<T, T, T, bool> ruleRight,
            T currentValue,
            T ruleLeftValue1,
            T ruleLeftvalue2,
            T ruleRightValue1,
            T ruleRightvalue2)
        {
            var result = ruleLeft(currentValue, ruleLeftValue1, ruleLeftvalue2) || ruleRight(currentValue, ruleRightValue1, ruleRightvalue2);
​
            return result;
        }
​
        #endregion
​
    }
                    
public class Program
{
    
    public static void Main()
    {
        var age = 20;
        var gender = true;
        
        //assum that age must be in range 30, 40 for male and in range 35, 45 for female
        var baseRule = new BaseRule();
        
        var result = (baseRule.IsBetweenTwoValues(age, 30, 40) && baseRule.IsEqual(gender, true)) || ((baseRule.IsBetweenTwoValues(age, 20, 30) && baseRule.IsEqual(gender, false)));
        
        var result2 = 
            baseRule.OneWayComparisonForTwoValues(
                baseRule.IsBetweenTwoValues,
                baseRule.IsBetweenTwoValues,
                age, 
                30, 
                40,
                20,
                30);
​
        var result3 = baseRule.OneWayComparisonForOneValues(
                baseRule.IsGreaterThan,
                baseRule.IsLessThan,
                age, 
                15, 
                40);    
        
        var result4 = baseRule.TwoWayComparisonForOneValues(
                baseRule.IsGreaterThan,
                baseRule.IsLessThanOrEqual,
                age, 
                15, 
                18);    
        
        
        Console.WriteLine("Result: " + result);
        Console.WriteLine("Result: " + result2);
        Console.WriteLine("Result: " + result3);
        Console.WriteLine("Result: " + result4);
        
    }
}

Hello World
text: 2

Cached Result
Last Run:	9:13:22 pm
Compile:	0.007s
Execute:	0.07s
Memory:	6.16Mb
CPU:	0.077s

View IL Code