Funciones de ayuda para la conversión segura de las cadenas

Question

Detrás 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 a mi productividad más al codificar que tener que agregar un código de caso especial para tratar con datos que podrían causar algún error irrelevante; 9999/10000 si algo que estoy usando como 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 ... entonces realmente no sé por dónde empezar a escribir mi nuevo conjunto de funciones auxiliares, o incluso si necesito hacerlo en absoluto.

Entonces, necesito escribir una función que acepte una cadena, un campo de base de datos, un campo de formulario/consulta de solicitud, ???, y luego hacer lo que sea para convertirlo en un Doble, y devolver ese al procedimiento de llamada.

También necesitaría hacer esto para pantalones cortos, int16, int32, largos, todo lo demás que podría interesarme.

Entonces haría esto para las cadenas. Y fechas.

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

Answer 1

Hay muchas 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 erran por el lado de la precaución cuando pasan entradas no válidas, y lanzan una excepción.

Afortunadamente, se puede escribir fácilmente un método de utilidad para convertir una cadena que representa un valor numérico, una cadena vacía 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 devolución del tipo del segundo argumento, que se usa como el 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 admiten nulos (números, fechas, etc.), solo cadenas son nulables. Si usted está recibiendo datos de una base de datos, entonces usted probablemente estará trabajando con Nullable, o su versión azucarada-sintáctica, int ?, doble ?, DateTime ?, etc.

Todos nullables tienen a method que le permiten obtener su valor real, o un valor predeterminado si son nulos. Esto debería ayudarte a evitar crear esas funciones.

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

También puede add extension methods si desea algunas funciones especiales no disponibles. 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).

Funciona básicamente como Convert.ToInt32 (val);

EDIT: Realmente necesito aprender a leer todas las palabras. No captó la preocupación sobre el nulo ... hay un operador para esto. Puedes usar el ?? para comprobar nulo y proporcionar un valor predeterminado, sin embargo, para que funcione.

Quizás también quiera mirar en LINQ, maneja mucho de ese tipo de mapeo para usted.

Answer 4

Creo que es similar a @ Shog9. Solo agrego un try catch para manejar la entrada inusual del usuario. Envío el tipo en el que quiero convertir la entrada y tomar 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 los llaman como a continuación

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);