ultimos - quitar los primeros 3 caracteres de una cadena c#

Compruebe si la cadena se puede convertir a un tipo dado en C#

Question

Esta pregunta ya tiene una respuesta aquí:

• La forma más rápida de verificar si una cadena se puede analizar 5 respuestas

Debo validar los datos de entrada del usuario y asegurar que el valor de una cadena sea convertible a un tipo especificado en tiempo de ejecución. No necesariamente necesito hacer la conversión real, simplemente realice una prueba para asegurarse de que el valor de entrada sea válido. No he encontrado una clase o método integrado que realice este tipo de evaluación, pero si me falta uno, házmelo saber. Estoy trabajando con C # 4.0, si hay alguna versión de soluciones específicas disponibles.

El método solo tiene que tratar con los tipos "estándar" (tipos de datos de valores incorporados más String). El único tipo personalizado que necesitaría evaluar son los tipos de enumeración específicos que se definen en la biblioteca.

Tengo 2 soluciones que estoy evaluando actualmente, pero ninguna de las dos es perfecta, así que esperaba que hubiera una tercera opción (o algo incorporado en el marco que me perdí). Me estoy inclinando fuertemente hacia la Solución n. ° 2 ya que el uso del try-catch en la Solución n. ° 1 parece incorrecto.

Solución 1 : Convert.ChangeType() con try / catch

public Boolean CheckType(String value, Type type)
{
    try
    {
        var obj = Convert.ChangeType(value, type);
        return true;
    }
    catch(InvalidCastException)
    {
        return false;
    }
    catch(FormatException)
    {
        return false;
    }
    catch(OverflowException)
    {
        return false;
    }
    catch(ArgumentNullException)
    {
        return false;
    }
}

Solución 2 cadena if / else con verificación de tipo y TryParse

public Boolean CheckType(String value, Type type)
{
    if (type == typeof(String))
    {
        return true;
    }
    else if (type == typeof(Boolean))
    {
        Boolean b;
        return Boolean.TryParse(value, out b); 
    }
    else if (type == typeof(Int32))
    {
        Int32 i;
        return Int32.TryParse(value, out i); 
    }
    else if (type == typeof(Int64))
    {
        Int64 l;
        return Int64.TryParse(value, out l); 
    }
    // similar code to check all other types 
    // (Int16, UInt32, UInt64, UInt16, Byte, SByte, Single, Double, Decimal,
    //  Enum, Char, DateTime)
    .
    .
    .
    .
    .
    else
        throw new ArgumentException("Invalid type evaluation");

}

Este método se puede llamar varios cientos o incluso mil veces en un intervalo corto si los datos de entrada están gravemente dañados o dañados, así que estoy preocupado de que las repetidas verificaciones if / else sean un lastre para el rendimiento (no estoy necesariamente tratando de optimizar en este punto, solo quiero asegurarme de que estoy considerando otras opciones).

El otro problema que tengo con ambas soluciones es que ambas realmente convierten el valor de la cadena a un nuevo valor del tipo esperado, y en ambos casos, me estoy tragando el resultado.

Answer 1

Considere usar TypeConverter y métodos genéricos. Esto evita muchas declaraciones if. Agregue su propio manejo de errores según la documentación de MSDN

 class Program
    {
        static T convert<T>(string s)
        {
            var typeConverter = TypeDescriptor.GetConverter(typeof(T));
            if (typeConverter != null && typeConverter.CanConvertFrom(typeof(string)))
            {
                return (T) typeConverter.ConvertFrom(s);
            }

            return default(T);
        }

        static void Main(string[] args)
        {
            int x = convert<int>( "45");
        }
    }

Answer 2

Preferiría el TryParse , porque las excepciones son costosas (rendimiento).

Answer 3

Encontré una solución mejor que cualquiera de mis ideas iniciales en otra pregunta que se hizo recientemente.

parapura rajkumar estaba en el camino correcto con la clase TypeConverter, pero el manejo de excepciones requerido para el método CanConvertFrom para eventos no excepcionales era lo que estaba tratando de evitar.

El método TypeConverter.IsValid resolvió mi problema, aunque no es ideal porque el método IsValid es solo un contenedor para el método CanConvertFrom y el manejo de excepciones requerido.

private Boolean CanCovert(String value, Type type)
{
    TypeConverter converter = TypeDescriptor.GetConverter(type);
    return converter.IsValid(value);
}