public GeneratorOptions <T> Range(Expression <Func <T, decimal> > propertyExpression, decimal min, decimal max)
        {
            var generator = new DecimalGenerator(min, max);

            return(For(propertyExpression, generator));
        }
        /// <summary>
        /// A factory for returning the appropriate generator
        /// </summary>
        /// <param name="thisCustomAttribute">The decoration defining the generator</param>
        /// <param name="thisPropInfo">The reflected values of the property</param>
        /// <returns>IRandomGenerator</returns>
        private IDataGenerator GetGenerator(CustomAttributeData thisCustomAttribute, PropertyInfo thisPropInfo)
        {
            IDataGenerator generator = null;

            switch (thisCustomAttribute.AttributeType.Name)
            {
            case "IntegerGenerator":
                generator = new IntegerGenerator();
                break;

            case "SingleGenerator":
                generator = new SingleGenerator();
                break;

            case "SingleRangeGenerator":
                generator = GetPropertyInfoAttribute <SingleRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new DoubleRangeGenerator(Single.MinValue, Single.MaxValue);
                }
                break;

            case "DoubleGenerator":
                generator = new DoubleGenerator();
                break;

            case "NormallyDistributedDoubleGenerator":
                generator = GetPropertyInfoAttribute <NormallyDistributedDoubleGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new NormallyDistributedDoubleGenerator(0, 1);
                }
                break;

            case "DoubleRangeGenerator":
                generator = GetPropertyInfoAttribute <DoubleRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new DoubleRangeGenerator(double.MinValue, double.MaxValue);
                }
                break;

            case "BoolGenerator":
                generator = new BoolGenerator();
                break;

            case "IntegerRangeGenerator":
                generator = GetPropertyInfoAttribute <IntegerRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new IntegerRangeGenerator(int.MinValue, int.MaxValue);
                }
                break;

            case "StringRangeGenerator":
                generator = GetPropertyInfoAttribute <StringRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new StringRangeGenerator(new string[] { "" });
                }
                break;

            case "DateRangeGenerator":
                generator = GetPropertyInfoAttribute <DateRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new DateRangeGenerator(DateTime.MinValue, DateTime.MaxValue);
                }
                break;

            case "StringFromFileGenerator":
                string pathAsKey = thisCustomAttribute.ConstructorArguments.First().ToString();
                // this is a cached generator, stored for the sake of not having to re-process the file
                if (cacheGenerators.ContainsKey(pathAsKey))
                {
                    generator = cacheGenerators[pathAsKey];
                }
                else
                {
                    // process the gerneator
                    generator = GetPropertyInfoAttribute <StringFromFileGenerator>(thisPropInfo);
                    // add to a cache
                    cacheGenerators.Add(pathAsKey, generator);
                }
                if (generator == null)
                {
                    generator = new StringRangeGenerator(new string[] { "" });
                }
                break;

            case "IntegerSequenceGenerator":
                var key = thisPropInfo.Name + "/" + thisCustomAttribute.AttributeType.Name;
                if (cacheGenerators.ContainsKey(key))
                {
                    generator = cacheGenerators[key];
                }
                else
                {
                    // process the gerneator
                    generator = GetPropertyInfoAttribute <IntegerSequenceGenerator>(thisPropInfo);
                    // add to a cache
                    cacheGenerators.Add(key, generator);
                }
                if (generator == null)
                {
                    generator = new IntegerSequenceGenerator();
                }
                break;

            case "DecimalGenerator":
                generator = new DecimalGenerator();
                break;

            case "DecimalRangeGenerator":
                generator = GetPropertyInfoAttribute <DecimalRangeGenerator>(thisPropInfo);
                if (generator == null)
                {
                    generator = new DecimalRangeGenerator(double.MinValue, double.MaxValue);
                }
                break;

            default:
                break;
            }

            return(generator);
        }