如何在 TryParse() 的泛型版本中转换为特定类型？

Question

我有以下场景，我想传入字符串和泛型类型：

public class Worker {
    public void DoSomeWork<T>(string value) 
        where T : struct, IComparable<T>, IEquatable<T> { ... }
}

在某些时候，我需要将字符串值转换为其T 值。但我不想直接转换，因为如果字符串无法转换为类型T，我需要执行一些逻辑。

我在想我可以尝试使用 Convert.ChangeType() 但这有一个问题，如果它不转换它会抛出异常，我将经常运行 DoSomeWork() 方法，而不必依赖try/catch 判断转换是否有效。

所以这让我想到，我知道我将使用数字类型，因此 T 将是以下任何一种：int、uint、short、ushort、long、@ 987654331@、byte、sbyte、decimal、float、double。知道这一点后，我认为可能会提出一个更快的解决方案，因为我知道我将使用数字类型（请注意，如果 T 不是数字类型，我会抛出异常）...

public class NumericWorker {
    public void DoSomeWork<T>(string value) 
        where T : struct, IComparable<T>, IEquatable<T> 
    { 
        ParseDelegate<T> tryConverter = 
           SafeConvert.RetreiveNumericTryParseDelegate<T>();
        ... 
    }
}


public class SafeConvert
{
    public delegate bool ParseDelegate<T>(string value, out T result);

    public static ParseDelegate<T> RetreiveNumericTryParseDelegate<T>()
        where T : struct, IComparable<T>, IEquatable<T>
    {
        ParseDelegate<T> tryParseDelegate = null;

        if (typeof(T) == typeof(int))
        {
           tryParseDelegate = (string v, out T t) =>
              {
                 int typedValue; 
                 bool result = int.TryParse(v, out typedValue);
                 t = result ? (T)typedValue : default(T); 
                 //(T)Convert.ChangeType(typedValue, typeof(T)) : default(T);
                 return result;
              }; 
        }
        else if (typeof(T) == typeof(uint)) { ... }
        else if (typeof(T) == typeof(short)) { ... }
        else if (typeof(T) == typeof(ushort)) { ... }
        else if (typeof(T) == typeof(long)) { ... }
        else if (typeof(T) == typeof(ulong)) { ... }
        else if (typeof(T) == typeof(byte)) { ... }
        else if (typeof(T) == typeof(sbyte)) { ... }
        else if (typeof(T) == typeof(decimal)) { ... }
        else if (typeof(T) == typeof(float)) { ... }
        else if (typeof(T) == typeof(double)) { ... }

        return tryParseDelegate;
    }
}

但是上面的问题是我不能写t = result ? (T)typedValue : default(T);，因为typedValue 到T 的转换会导致问题，到目前为止我能够解决它的唯一方法是写@987654342 @。但如果我这样做，我只是在做另一个转换。

因此我想知道是否有人知道我可以如何解决这个问题（如果您认为执行 ChangeType() 是一个问题），或者是否有更好的解决方案我没有考虑过。

Answer 1

t = 结果？ (T)typedValue : 默认值(T);

试试：

t = result ? (T)(object)typedValue : default(T);

是的，泛型有时会有点烦人。

FWIW，我在Convert.ChangeType() 周围使用a much simpler wrapper，它只是对空字符串进行预检查。除非您将其用于未经检查的用户输入，否则可能就足够了。

Answer 2

鉴于此：

因此 T 将是以下任何一种：int、uint、short、ushort、long、ulong、byte、sbyte、decimal、float、double。

我建议只使用 Convert.ChangeType，而不用担心它。唯一出现异常的情况是您的字符串格式错误，在这种情况下，您可以返回 default(T)。

即：

try
{
    result = Convert.ChangeType(value, typeof(T));
}
catch
{
    result = default(T);
}

Answer 3

ToType 是这里的通用参数。这适用于可为空的类型，以防万一您需要它。您可以将您的主要方法提取为通用转换器，它将转换为任何类型，包括可为空的。

    ToType result = default(ToType);    

    result = ChangeType<ToType>(typedValue);


  private T ChangeType<T>(object o)
{
   Type conversionType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
   return (T)Convert.ChangeType(o, conversionType);
}

Answer 4

你可以尝试一些简单的事情

    public static T ConvertValue<T,U>(U value) where U : IConvertible {
        return (T)ConvertValue(value, typeof(T));
    }

    public static object ConvertValue(IConvertible value, Type targetType) {
        return Convert.ChangeType(value, targetType);
    }

Answer 5

为什么不直接使用反射并使用内置的 TryParse 方法？除了 Guid 之外，几乎每种原生类型都有一个。

public static Parser<T> GetParser<T>(T defaultResult)
    where T : struct
{
    // create parsing method
    Parser<T> parser = (string value, out T result) =>
    {
        // look for TryParse(string value,out T result)
        var parseMethod = 
            typeof(T).GetMethods()
                     .Where(p => p.Name == "TryParse")
                     .Where(p => p.GetParameters().Length == 2)
                     .Single();

        // make parameters, leaving second element uninitialized means out/ref parameter
        object[] parameters = new object[2];
        parameters[0] = value;

        // run parse method
        bool success = (bool)parseMethod.Invoke(null, parameters);

        // if successful, set result to output
        if (!success)
        {
            result = (T)parameters[1];
        }
        else
        {
            result = defaultResult;
        }

        return success;
    };

    return parser;
}