如何编写通用扩展方法？

Question

I am developing a generic wrapper around TryParse, as follows:

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

    public static T? ParseOrNull<T>(this string value, ParseDelegate<T> parse) where T : struct
    {
        T result;
        var parsed = parse(value, out result);
        return parsed ? result : (T?)null;
    }

    [Test]
    public void ParsesValidInt()
    {
        Assert.AreEqual(1234, "1234".ParseOrNull<int>(int.TryParse));
    }

    [Test]
    public void ParsesValidDecimal()
    {
        Assert.AreEqual(12.34M, "12.34".ParseOrNull<decimal>(decimal.TryParse));
    }

This is kinda repetitive. Is there a way to avoid mentioning int.TryParse at all, so that my calls look as follows:

"1234".ParseOrNull<int>()

Answer 1

Is there a way to avoid mentioning int.TryParse at all, so that my calls look as follows:

Not directly, as TryParse isn't part of a shared interface. If there were a shared interface to these value types, this would be possible via a constraint.

---

Personally, I would not suggest using extension methods for this. I would rather write this as something more like:

public static class Parse
{
    public delegate bool ParseDelegate<T>(string s, out T result);
    public static T? FromString<T>(string value, ParseDelegate<T> parse) where T : struct
    {
        T result;
        var parsed = parse(value, out result);
        return parsed ? result : (T?)null;
    }
    public static int? ToNullableInt32(string value)
    {
        return FromString<int>(value, int.TryParse);
    }
    public static double? ToNullableDouble(string value)
    {
        return FromString<double>(value, double.TryParse);
    }
}

This adds a bit of overhead up front, but allows you to write these very cleanly, ie:

    int? first = Parse.FromString<int>("1234", int.TryParse);
    int? second = Parse.ToNullableInt32("1234");
    double? third = Parse.ToNullableDouble("1234");

I see little value in putting an extension method, especially on something like string (which is used everywhere), as it "pollutes" the compilation of string itself. You'll see this everywhere you use strings - basically, any time you use this namespace, you'll end up having these parse methods in your intellisense, etc. In addition, this seems more like a "utility" than something that should appear as built-in functionality of string itself, which is why I personally prefer a separate class for it.

Answer 2

In short no but you can add a new helper method:

public static int? ParseInt(this string value)
{
  return value.ParseOrNull<int>(int.TryParse);
}

and then:

"1234".ParseInt();

Answer 3

Look at how Microsoft deals with several types . They provides one method for each type. Enumerable.Sum Method is a good example. If you want to simplify the calling code, you should provide the overloads for each types :

public static int? ParseOrNull<int>(this string value) 
{
    int result;
    var parsed = int.TryParse(value, out result);
    return parsed ? result : (T?)null;
}
public static long? ParseOrNull<long>(this string value) 
{
    long result;
    var parsed = long.TryParse(value, out result);
    return parsed ? result : (T?)null;
}
// same for ulong, long, uint, ushort, short, byte, 
// bool, float, double, decimal. Do I forget one ?

I think it's more important to simplify calls than the method itself. In fact, there is not a huge number of types to deal with.

Answer 4

The answer is a big YES. You're trying to exploit the existence of the static T.TryParse(string, out T) function on the types you're converting to, and we can do that pretty easily with a little reflection.

public static T? ParseOrNull<T>(this string str)
    where T: struct, IConvertible
{
    // find the TryParse method.
    var parseMethod = typeof(T).GetMethod("TryParse", 
                                    // We want the public static one
                                    BindingFlags.Public | BindingFlags.Static,
                                    Type.DefaultBinder,
                                    // where the arguments are (string, out T)
                                    new[] { typeof(string), typeof(T).MakeByRefType() },
                                    null);
    if (parseMethod == null)
        // You need to know this so you can parse manually
        throw new InvalidOperationException(
                            string.Format("{0} doesn't have a TryParse(..) function!",
                                                    typeof(T).FullName));
    // create the parameter list for the function call
    var args = new object[] { str, default(T) };
    // and then call the function.
    if ( (bool)parseMethod.Invoke(null, args))
        return (T?)args[1]; // if it returned true
    // if it returned false
    return null;
}

This is the original answer I provided, based on the idea that you need two different parse methods: One for value types and another for reference types.

    public delegate bool ParseDelegate<T>(string s, out T result);
    public static T? ParseOrNull<T>(this string str, ParseDelegate<T> Parse)
        where T: struct
    {
        T result;
        if (!Parse(str, out result))
            return null;
        return result;
    }

    public static T ParseOrNull<T>(this string str, ParseDelegate<T> Parse)
        where T : class
    {
        T result;
        if (!Parse(str, out result))
            return null;
        return result;
    }

Answer 5

Yes , you can use Convert.ChangeType

public static T? ParseOrNull<T>(this string value) where T : struct, IConvertible
{
    try
    {           
        return (T)Convert.ChangeType(value, typeof(T));
    }
    catch (FormatException ex)
    {
        return null;
    }
}

It wont have as good performance (use of try catch) as TryParse , but should work for all IConvertible types

Answer 6

public static T? ParseOrNull<T>(this string value)
            where T : struct
        {
            T result = default(T);

            object[] parameters = new object[] { value, result };
            foreach (System.Reflection.MethodInfo method in
                typeof(T).GetMethods()
                .Where(method => method.Name == "TryParse")
                .Where(method => method.GetParameters().Length == 2) //as opposed to the 4 argument version
                .Take(1) //shouldn't be needed, but just in case
                )
            {
                method.Invoke(null, parameters);
            }

            return (T)parameters[1];
        }

As Reed mentions, I'd rather not use an extension method of string. I'd just use Parser.Parse(string value). Easy fix though, just remove the 'this' and voila.