Funciones de ayuda para la conversión segura de cadenas

Question

En VB6, escribí algunas funciones que me permitirían codificar sin tener que preocuparme por la diferencia entre nulo y '' para cadenas, nulo y 0 para números, etc. Nada mata más mi productividad al codificar que tener que agregue código de caso especial para tratar con datos que puedan causar algún error irrelevante; 9999/10000 si algo que estoy usando como un número es nulo, entonces realmente lo trato como 0.

Ahora estoy en C #, y la diferencia entre VB6 y C # 2005 es bastante extensa ... por lo que realmente no sé por dónde empezar a escribir mi nuevo conjunto de funciones auxiliares, o si incluso necesito hacerlo ellos en absoluto.

Entonces, necesito escribir una función que acepte una cadena, un campo de base de datos, un formulario de solicitud / campo de consulta, ???, y luego hacer lo que sea posible para convertir eso en un Doble, y devolverlo a El procedimiento de llamada.

También necesitaría hacer esto para los shorts, int16, int32, long, todo lo demás que pueda interesarme.

Entonces haría esto por cuerdas. Y fechas.

¿Es esta una actividad que vale la pena? ¿Hay algo en el marco o C # que pueda usar en su lugar? Realmente deseo algo que me permita utilizar los datos en línea para llamar a otras funciones y no tener que crear variables temporales, etc.

Answer 1

Hay montones de funciones de conversión incorporadas. Pero ... no estoy seguro de que ninguno de ellos haga exactamente lo que quieres. En general, los métodos .NET se equivocan en el lado de la precaución cuando se pasa una entrada no válida y se produce una excepción.

Afortunadamente, puede escribir fácilmente un método de utilidad para convertir una representación de cadena de un valor numérico, una cadena vacía o una cadena nula a cualquier tipo de salida:

public static T SafeConvert<T>(string s, T defaultValue)
{
    if ( string.IsNullOrEmpty(s) )
        return defaultValue;
    return (T)Convert.ChangeType(s, typeof(T));
}

Uso:

SafeConvert(null, 0.0) == 0.0;
SafeConvert("", 0.0) == 0.0;
SafeConvert("0", 0.0) == 0.0;

Este método genérico toma su tipo de retorno del tipo del segundo argumento, que se utiliza como valor predeterminado cuando la cadena pasada es nula o está vacía. Pase 0 y obtendrá un In32 de vuelta. Pase 0L , Int64 . Y así sucesivamente ...

Answer 2

En C #, la mayoría de los tipos de datos no son anulables (números, fechas, etc.), solo las cadenas son anulables. Si está obteniendo datos de una base de datos, entonces probablemente estará trabajando con Nullable , o su versión con azúcar sintáctica, int, double, DateTime ?, etc.

Todos los nullables tienen un método que le permite obtener su valor real o un valor predeterminado si son nulos. Esto debería ayudarlo a evitar crear esas funciones.

En cuanto a las cadenas, tiene la función String.IsNullOrEmpty (str).

También puede agregar métodos de extensión si desea alguna especial Funcionalidad no disponible. Tenga en cuenta que los métodos de extensión se pueden aplicar a valores nulos, siempre que lo maneje en el código. Por ejemplo:

public static string ValueOrDefault(this string str) 
{
     if (String.IsNullOrEmpty(str)) return MY_DEFAULT_VALUE;
     else return str;
}

Answer 3

Hay una clase llamada Convertir en la biblioteca .NET. Tiene funciones que le permiten convertir lo que necesite de cualquier tipo base y algunas de las clases comunes (como DateTime).

Básicamente funciona como Convert.ToInt32 (val);

EDITAR: Realmente necesito aprender a leer todas las palabras. No capté la preocupación por null ... hay un operador para esto. Puedes usar el ?? para verificar si hay un valor nulo y proporcionar un valor predeterminado, sin embargo, para que pueda funcionar.

Es posible que también desee ver LINQ, ya que maneja mucho de ese tipo de mapeo por usted.

Answer 4

Creo que es similar a @ Shog9. Acabo de agregar un try catch para manejar la entrada inusual del usuario. Envío el tipo en el que quiero convertir la entrada y tomo la entrada como objeto.

public static class SafeConverter
{
   public static T SafeConvert<T>(object input, T defaultValue)
   {
       if (input == null)
          return defaultValue; //default(T);

       T result;
       try
       {
           result = (T)Convert.ChangeType(input.ToString(), typeof(T));
       }
       catch
       {
          result = defaultValue; //default(T);
       }
       return result;
   }
} 

Ahora llámalos como abajo

SafeConverter.SafeConvert<ushort>(null, 0);
SafeConverter.SafeConvert<ushort>("", 0);
SafeConverter.SafeConvert<ushort>("null", 0);
SafeConverter.SafeConvert<ushort>("-1", 0);
SafeConverter.SafeConvert<ushort>("6", 0);
SafeConverter.SafeConvert<ushort>(-1, 0);
SafeConverter.SafeConvert<ushort>(0, 0);
SafeConverter.SafeConvert<ushort>(1, 0);
SafeConverter.SafeConvert<ushort>(9, 0);