una - validar si string es numero c#

Cómo determinar si una cadena es un número en C#

Question

Estoy trabajando en una herramienta en la que necesito convertir valores de cadena a sus tipos de objeto adecuados. Por ejemplo, convierta una cadena como "2008-11-20T16:33:21Z" en un valor DateTime . Los valores numéricos como "42" y "42.42" deben convertirse a un valor Int32 y un valor Double , respectivamente.

¿Cuál es el mejor y más eficiente enfoque para detectar si una cadena es un número entero o un número? Son Int32.TryParse o Double.TryParse el camino a seguir?

Answer 1

En términos de eficiencia, sí, TryParse es generalmente la ruta preferida.

Si puede conocer (por ejemplo, por reflexión) el tipo de destino por adelantado, pero no quiere tener que usar un gran bloque de switch , puede que le interese usar TypeConverter , por ejemplo:

        DateTime foo = new DateTime(2008, 11, 20);
        TypeConverter converter = TypeDescriptor.GetConverter(foo);
        string s = converter.ConvertToInvariantString(foo);
        object val = converter.ConvertFromInvariantString(s);

Answer 2

Manteniendo la idea de un convertidor para saltear un bloque de interruptores, puedes usar el concepto de Duck Typing. Básicamente, desea convertir una cadena en X, por lo que crea un método que llamará X.TryParse (cadena, fuera X x) si X tiene TryParse en él, de lo contrario no se molestará (o supongo que podría lanzar un error). ¿Cómo harías esto? Reflexión y genéricos

Básicamente, tendrías un método que tomaría un tipo y usarías un reflejo para ver si tiene TryParse en él. Si encuentra un método así, llámelo y devuelva lo que TryParse logró obtener. Esto funciona bien con casi cualquier tipo de valor, como Decimal o DateTime.

public static class ConvertFromString
{
  public static T? ConvertTo<T>(this String numberToConvert) where T : struct
  {
    T? returnValue = null;

    MethodInfo neededInfo = GetCorrectMethodInfo(typeof(T));
    if (neededInfo != null && !numberToConvert.IsNullOrEmpty())
    {
      T output = default(T);
      object[] paramsArray = new object[2] { numberToConvert, output };
      returnValue = new T();

      object returnedValue = neededInfo.Invoke(returnValue.Value, paramsArray);

      if (returnedValue is Boolean && (Boolean)returnedValue)
      {
        returnValue = (T)paramsArray[1];
      }
      else
      {
        returnValue = null;
      }    
    }

    return returnValue;
  }
}

Donde GetCorrectMethodInfo se vería así:

private static MethodInfo GetCorrectMethodInfo(Type typeToCheck)
{

  MethodInfo returnValue = someCache.Get(typeToCheck.FullName);

  if(returnValue == null)
  {
    Type[] paramTypes = new Type[2] { typeof(string), typeToCheck.MakeByRefType() };
    returnValue = typeToCheck.GetMethod("TryParse", paramTypes);
    if (returnValue != null)
    {
      CurrentCache.Add(typeToCheck.FullName, returnValue);
    }
  }

  return returnValue;
}

Y el uso sería:

decimal? converted = someString.ConvertTo<decimal>();

Odio enchufarme, pero tengo todo esto explicado aquí:

GetCorrectMethodInfo

Resto de eso

Answer 3

Yo recomendaría el .TryParse () personalmente. Eso es lo que uso de todos modos. Eso es si sus datos van a estar equivocados de vez en cuando. Si está seguro de que las cadenas entrantes podrán convertirse en enteros o dobles sin un enganche, el .Parse () es más rápido.

Aquí hay un enlace interesante para apoyar esto.

Answer 4

Int.TryParse y Double.TryParse tienen el beneficio de devolver el número.

Algo como Regex.IsMatch("^/d+$") tiene el inconveniente de que todavía tiene que analizar la cadena de nuevo para obtener el valor.