.NET - Parse data type without result

Question

Is it possible to parse a data type (int, double, boolean...) in .NET without throwing an exception and without returning the result? In other words, I just want to be able to answer the question, 'Is this a valid integer?' or 'Is this a valid double?' without having to declare a result variable. I do not want to use .TryParse because I have to pass in a result variable, and I do not want to use .Parse because it will throw.

Any suggestions? (I would be surprised if this functionality wasn't present in .NET, I must be missing something.)

EDIT

Ok, this was too easy... just made a couple extension methods and I'm on my way...

    <Extension()> _
    Public Function IsValidInteger(ByVal value As String) As Boolean
        Dim result As Integer
        Return Integer.TryParse(value, result)
    End Function

    <Extension()> _
    Public Function IsValidDouble(ByVal value As String) As Boolean
        Dim result As Double
        Return Double.TryParse(value, result)
    End Function

Looks like this a duplicate question, however, in all honesty, I didn't find this one until now:

Integer.TryParse - a better way?

The accepted answer from that question is probably better than anything suggested here.

@Colin - Because of the necessity to pass it a result variable. Perhaps I'll have a look at these so called 'extension methods' mentioned below. — Oceanic7, Dec 15 '10 at 17:32
Extension methods are enormously useful when creating a domain-specific language since they afford you more control over the semantics of the code, allowing things to be expressed in a more business-intuitive way. — David, Dec 15 '10 at 17:40
How are you avoiding `TryParse` here? You are simply wrapping it in extension methods. — Oded, Dec 16 '10 at 10:56

score 2 · Answer 1 · answered Dec 15 '10 at 17:26

2

You can use the different TryParse methods defined on the types.

This the best you can do without writing your own parser/tokenizer.

answered Dec 15 '10 at 17:26

Oded

489,969
99
883
1,009

Apparently you don't have to write your own parser/tokenizer, you can just use these magical extension methods. – Oceanic7 Dec 15 '10 at 17:46
@Oceanic7: "Magical"? It's just the Open/Closed Principle in action, with some syntactical sugar to make it a little easier. – David Dec 16 '10 at 00:20

score 2 · Answer 2 · answered Dec 15 '10 at 17:38

No, there is no such functionality in the framework.

The reason is that there is so little gain in only determining if a string is parsable compared to actually parsing it, that it's just not worth it to have both methods.

Almost always when you want to find out if it's possible to parse a string, you will also want to parse the string. If there was a method to just find out if it was possible to parse a string, it would frequently be misused in this way, causing the string to be parsed twice:

if (Int32.CanParse(theString)) {
  int n = Int32.Parse(theString);
}

The TryParse method does it in a single operation, and it also works in your very unusual case, with only the inconvenience of having to declare a variable for the result.

Ani · Answer 3 · 2010-12-15T17:44:16.850

I don't think there is anything in the framework for this. As Guffa points out, the provision of such methods in the framework would be of limited use.

But if you really wanted, you could write a "convention-based" extension-method like:

public static class ParseExtensions
{
    public delegate bool TryParser<T>(string input, out T result);

    public static bool CanParseTo<T>(this string text, TryParser<T> tryParser)
    {
        if (text == null)
            throw new ArgumentNullException("text");

        if (tryParser == null)
            throw new ArgumentNullException("tryParser");

        T result;
        return tryParser(text, out result);
    }
}

Usage (it's a pity type-inference doesn't work here):

bool intTrue = "123".CanParseTo<int>(int.TryParse);
bool intFalse = "xxx".CanParseTo<int>(int.TryParse);

bool enumTrue = "Encrypted".CanParseTo<FileOptions>(Enum.TryParse<FileOptions>);
bool enumFalse = "xxx".CanParseTo<FileOptions>(Enum.TryParse<FileOptions>);

bool dateTimeTrue = "2004/05/05".CanParseTo<DateTime>(DateTime.TryParse);
bool dateTimeFalse = "xxx".CanParseTo<DateTime>(DateTime.TryParse);

score 0 · Answer 4 · answered Dec 15 '10 at 17:29

Yes make your own extension methods for that, the methods aren't present because it's not something that people use everyday . . .

public bool IsValidInt(this int someInt, string toCheck) { int dontNeed; return Int.TryParse(toCheck, out dontNeed); }

score 0 · Answer 5 · answered Dec 15 '10 at 17:29

0

You could write yourself an extension method that will do the job for you more conveniently than using TryParse every time, if you just want to avoid that. Something like:

public static bool IsValidDateFormat(this string s)
{
    DateTime dt;
    return DateTime.TryParse(s, out dt);
}

(There may be a slightly more elegant way to do it, I just threw this together to be compilable.)

answered Dec 15 '10 at 17:29

David

208,112
36
198
279

There's no point in initializing `dt` since you then use it as an `out` parameter – Tim Robinson Dec 15 '10 at 17:31
@Tim Robinson: Good point. It's not being used for anything, after all. Updated. – David Dec 15 '10 at 17:32

score 0 · Answer 6 · answered Dec 15 '10 at 17:46

Try this function below:

public bool isValid<T>(object t)
{
    try
    {
        Convert.ChangeType(t, typeof(T));
        return true;
    }
    catch(Exception e)
    {
        return false;
    }
}

You needn't to write an extension for every basic types combinations because this method is generic. Example:

bool isValidInt = isValid<int>("t14");
//isValidInt == false
bool isValidInt2 = isValid<int>("144");
//isValidInt2 == true

.NET - Parse data type without result

6 Answers6