Dan S <Da**@discussio ns.microsoft.co m> wrote:
My application asks the user to enter in a date - in the mm/dd/yyyy
format. Is there any quick and easy way to verify the date the user
enters is formatted correctly? Right now I'm calling DateTime.Parse( )
and catching the FormatException but it seems this is a bit
inefficient - catching the exception that is. There is some pretty
obvious delay while it traces back up the call stack. Is there a
better way? Something that returns a bool possibly?
After the first time, which may involve a delay due to loading
resources, throwing an exception is likely to be very fast - far faster
than a user can actually notice. On my laptop I can throw a hundred
thousand exceptions in a second - I think that's rather more than a
user is likely to enter.
I'm not saying that exceptions are always a nice way to go, but I
wouldn't dismiss them for performance reasons - at least not in this
case.
You can use a regular expression to check the format, of course - but
you may well find that doing so is more expensive than just trying to
parse the date and catching the exception.
You could probably do slightly better with a hard-coded test, something
like:
static readonly char[] LowerBounds = "00/00/1000".ToCharArr ay();
static readonly char[] UpperBounds = "19/39/2999".ToCharArr ay();
static bool IsProbablyValid Date(string date)
{
if (date.Length != 10)
{
return false;
}
for (int i=0; i < date.Length; i++)
{
char c=date[i];
if (c < LowerBounds[i] || c > UpperBounds[i])
{
return false;
}
}
return true;
}
That gets rid of *many* invalid dates, but not all - you'll still need
to call DateTime.Parse (or preferrably DateTime.ParseE xact) and catch
the potential exception, unless you want to do all the parsing
correctly.
Note that it also requires the leading zeroes for months and days - if
you don't want that, it becomes slightly trickier.
(That only deals with dates in years 1000-2999; if you need to deal
with earlier or later years, change the 7th character in
LowerBounds/UpperBounds.)
Here's a benchmark to compare the three approaches mentioned:
using System;
using System.Windows. Forms; // For MethodInvoker
using System.Text.Reg ularExpressions ;
using System.Globaliz ation;
delegate void DoSomething();
class Test
{
static string[] invalid = {"123123", "wibble", "32/12/3223",
"14/23/1999", "04/35/1992", "02/29/2003"};
static string[] valid = {"12/02/2321", "02/12/2312", "02/29/2004",
"01/30/2000"};
const int Iterations = 100000;
static void Main()
{
Time (new MethodInvoker(T estRegex));
Time (new MethodInvoker(T estHardCoded));
Time (new MethodInvoker(T estNoPreCheck)) ;
}
static void Time(MethodInvo ker test)
{
DateTime start = DateTime.Now;
test();
DateTime end = DateTime.Now;
Console.WriteLi ne ("{0}: {1}", test.Method.Nam e, end-start);
}
static readonly Regex Expression = new Regex
(@"\d{1,2}\/\d{1,2}\/\d{4}", RegexOptions.Co mpiled);
static void TestRegex()
{
for (int i=0; i < Iterations; i++)
{
foreach (string x in invalid)
{
if (Expression.IsM atch(x))
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
throw new Exception("Inva lid date passed");
}
catch
{
}
}
}
foreach (string x in valid)
{
if (Expression.IsM atch(x))
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
}
catch
{
throw new Exception("Vali d date failed");
}
}
else
throw new Exception("Vali d date failed");
}
}
}
static void TestHardCoded()
{
for (int i=0; i < Iterations; i++)
{
foreach (string x in invalid)
{
if (IsProbablyVali dDate(x))
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
throw new Exception("Inva lid date passed");
}
catch
{
}
}
}
foreach (string x in valid)
{
if (IsProbablyVali dDate(x))
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
}
catch
{
throw new Exception("Vali d date failed");
}
}
else
throw new Exception("Vali d date failed");
}
}
}
static void TestNoPreCheck( )
{
for (int i=0; i < Iterations; i++)
{
foreach (string x in invalid)
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
throw new Exception("Inva lid date passed");
}
catch
{
}
}
foreach (string x in valid)
{
try
{
DateTime.ParseE xact(x, "dd/mm/yyyy",
CultureInfo.Inv ariantCulture);
}
catch
{
throw new Exception("Vali d date failed");
}
}
}
}
static readonly char[] LowerBounds = "00/00/1000".ToCharArr ay();
static readonly char[] UpperBounds = "19/39/2999".ToCharArr ay();
static bool IsProbablyValid Date(string date)
{
if (date.Length != 10)
{
return false;
}
for (int i=0; i < date.Length; i++)
{
char c=date[i];
if (c < LowerBounds[i] || c > UpperBounds[i])
{
return false;
}
}
return true;
}
}
The results on my laptop were:
TestRegex: 00:00:09.343750 0
TestHardCoded: 00:00:04.343750 0
TestNoPreCheck: 00:00:12.515625 0
Changing the regex to require exactly two digits instead of 1 or 2 for
the month and day sped it up very slightly, but not really
significantly.
--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too
