Funções auxiliares para conversão segura de strings

Question

De volta ao VB6, escrevi algumas funções que me permitiriam codificar sem ter que me preocupar com a diferença entre null e '' para strings, null e 0 para números, etc.Nada mata mais minha produtividade durante a codificação do que ter que adicionar código de caso especial para lidar com dados que podem causar algum erro irrelevante;9999/10000 se algo que estou usando como número for nulo, então realmente o trato como 0.

Agora estou em C#, e a diferença entre VB6 e C# 2005 é bastante extensa...então não sei por onde começar a escrever meu novo conjunto de funções auxiliares, ou se preciso fazê-las. .

Então, eu preciso escrever uma função que aceite uma string, um campo de banco de dados, um formulário de solicitação/campo de consulta, ???, e então fazer o que for possível para transformar isso em um Double e retornar para o procedimento de chamada .

Eu também precisaria fazer isso para shorts, int16, int32, long, tudo o mais que eu possa me importar.

Então eu faria isso para strings.E datas.

Esta é uma busca que vale a pena?Existe algo na estrutura ou C# que eu possa usar?Eu realmente desejo algo que me permita usar dados embutidos na chamada de outras funções, e não ter que criar variáveis ​​temporárias, etc.

Answer 1

Existem inúmeras funções de conversão integradas.Mas...não tenho certeza se algum deles faz exatamente o que você deseja.Geralmente, os métodos .NET erram por excesso de cautela quando passam por uma entrada inválida e lançam uma exceção.

Felizmente, você pode escrever facilmente um método utilitário para converter uma representação de string de um valor numérico, uma string vazia vazia ou uma string nula para qualquer tipo de saída:

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

Usar:

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

Este método genérico obtém seu tipo de retorno do tipo do segundo argumento, que é usado como valor padrão quando a string passada é nula ou vazia.Passar 0 e você obteria um In32 voltar.Passar 0L, Int64.E assim por diante...

Answer 2

Em C#, a maioria dos tipos de dados não são anuláveis ​​(números, datas, etc.), apenas strings são anuláveis.Se você estiver obtendo dados de um banco de dados, provavelmente trabalhará com Anulável, ou sua versão com açúcar sintático, int?, double?, DateTime?, etc.

Todos os anuláveis ​​têm um método que permitem obter seu valor real ou um valor padrão se forem nulos.Isso deve ajudá-lo a evitar a criação dessas funções.

Quanto às strings, você tem a função String.IsNullOrEmpty(str).

Você também pode adicionar métodos de extensão se você quiser alguma funcionalidade especial não disponível.Observe que os métodos de extensão podem ser aplicados a valores nulos, desde que você os manipule no código.Por exemplo:

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

Answer 3

Existe uma classe chamada Convert na biblioteca .NET.Possui funções que permitem converter para o que você precisa de qualquer tipo base e algumas das classes comuns (como DateTime).

Basicamente funciona como Convert.ToInt32(val);

EDITAR:Eu realmente preciso aprender a ler todas as palavras.Não percebi a preocupação com null ...existe um operador para isso.Você pode usar o ??para verificar se há nulo e fornecer um padrão para que possa funcionar.

Você também pode querer dar uma olhada no LINQ, ele lida com muito desse tipo de mapeamento para você.

Answer 4

Acho que é semelhante ao @ Shog9.Acabei de adicionar um try catch para lidar com entradas incomuns do usuário.Envio o tipo no qual desejo converter o input e pego o input 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;
   }
} 

Agora chame-os como abaixo

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