Estava dando manutenção em um código que basicamente validava 30 campos com a seguinte regra.
Se o campo for vazio passar nulo para a procedure
Senão for validar se o campo é do tipo esperado (DateTime, Numeric, etc).
Basicamente o código era igual ao abaixo para cada campo.
string valor = “20/01/01”;
DateTime? data = null;
DateTime dataTemp;
if( (!string.IsNullOrEmpty(valor)) && DateTime.TryParse(valor, out dataTemp))
{
data = new Nullable<DateTime>(dataTemp);
}
Então resolvi cria uma função genérica e fazer testes de performance, para verificar qual solução implementar na solução. Veja as opções , ambas bem extensas =)
static bool TryParseException<T>(string text, out T value)
{
value = default(T);
try
{
value = (T)Convert.ChangeType(text, typeof(T));
return true;
}
catch
{
return false;
}
}
public static bool TryParseReflection<T>(string input, out T value) where T : struct
{
var type = typeof(T);
value = default(T);
var method = type.GetMethod(
“TryParse”,
new[] { typeof(string), Type.GetType(string.Format(“{0}&”, type.FullName)) });
return (bool)method.Invoke(null, new object[] { input, value });
}
Para os campos com valores compativeis com o tipo esperado a versão com Exception foi mais rápida, claro que era esperado porque com o valor esta no formato esperado não é disparada nenhum exception. Comparativo para 30 campos (0,015 s X 0.062 s)
Agora quandos os valores não são compativeis a versão que usa Reflection é infinitamente mais rápida. Comparativo para 30 campos (0,003 s X 1.5 s)
Pelos meus testes é bem mais interessante utilizar a versão com Reflection, pois mesmo quando é mais lenta é uma diferença que um usuário não perceberá a diferença.
Claro que se você for processar milhões de registros e 99.99% for o tipo correto seja mais interessante utilizar a versão com Exception =)
