Steve Michelotti

When I try to compile this I get a series of compiler errors the first is: "Constraints are not allowed on non-generic declarations". If I then comment out the constraint I get "The type or namespace name 'T' could not be found". After a series of changes to make this compile I eventually get "'out System.Nullable': static types cannot be used as parameters"

Maybe I'm missing something? Has anyone actually gotten this code to compile?

Eureka!
I finally got this to work, the following is the new declaration that will allow the code to compile.

public delegate bool TryParseDelegate<T>(string s, out T result);

public static bool TryParseNullable<T>(string s, out Nullable<T> result, TryParseDelegate<T> tryParse) where T : struct

Unit testing proved that there was a difference between calling Decimal.TryParse versis the generic TryParseNullable method. Here is the correction that makes it return the same results as if it were being called directly:

public static bool TryParseNullable<T>(string value, out Nullable<T> result, TryParseDelegate<T> tryParse) where T : struct {
if (string.IsNullOrEmpty(value)) {
result = default(T);
return false;
} else {
T temp;
bool success = tryParse(value, out temp);
result = temp;
return success;
}
}

Just ran across this and had to comment, I know it's a few months behind.

The point of this utility is not to mimic the .TryParse() method exactly, but to provide some simple methods that will allow nullable types to paly nice with UI.

I can see how one might have a need for utilities to parse data into nullable types, and would want the parsing routines to behave exactly like the built-ins. But then the question is why are you using nullable types in the first place? The TryParse is designed to return the default value if it is passed a null or an invalid string.

My $.02

in response to RK:
nullables are handy in a variety of situations but in my case, I'm using nHibernate and it can map a null data member to a dbnull in the database and this code gives me a clean way of handling the conversion from the UI.

Hey Steve,

Nice piece of code. I reworked it a bit to get it even a bit more generic.
public interface ITryParsable<T>
{
bool tryParse(string text, out T result);
}

/// <summary>
/// A parser for nullable types. Will return null when parsing fails.
/// </summary>
/// <typeparam name="T"></typeparam>
///
public class NullableParser<T> where T:struct, ITryParsable<T>
{ /// <summary>
/// A generic Nullable Parser. Supports parsing of all types that implements the tryParse method;
/// </summary>
/// <param name="text">The text.</param>
/// <param name="result">The result.</param>
/// <param name="parser">The parser.</param>
/// <returns></returns>
public static bool GenericNullableParse(string text, out Nullable<T> result,ITryParsable<T> parser)
{
if (string.IsNullOrEmpty(text))
{
result = null;
return true;
}
else
{
T valueToParse;

bool success = parser.tryParse(text, out valueToParse);
if (success)
{
result = valueToParse;
}
else
{
result = null;
}
return success;
}
}

Can be called like this now:

NullableParser<DateTime>.GenericNullableParse(TextBox.Text, out from, DateTime);

here's another option, works better out of the box

I think this one should make even more sense. Why we should always declare a variable to use it as an out parameter

public static Nullable<T> TryParseNullable<T>(string value, TryParseDelegate<T> tryParse) where T : struct
{
Nullable<T> result = default(T);
if (!string.IsNullOrEmpty(value))
{
T temp ;
bool success = tryParse(value, out temp);
result = temp;
}
return result;
}

Now use it as
Nullable<DateTime> d = TryParseNullable(str, DateTime.TryParse);

Or rather pass it directly to a function (Eg. adapter.update(..))

Here is a nullable tryparse that is generic and does not require a delagate http://johndauphine.blogspot.com/2009/10/nullable-tryparse-function-in-c.html

This is how I call it NullableParser<double>.TryParse("10.5", out _NullableDouble );