Verificar se um objeto é um número em C #

Eu gostaria de verificar se um objeto é um número para que .ToString()resultaria em uma string contendo dígitos e +, -,.

É possível digitando simplesmente em .net (como:) if (p is Number)?

Ou devo converter em string e depois tentar analisar em double?

Atualização: Para esclarecer, meu objeto é int, uint, float, double e assim por diante, não é uma string. Estou tentando fazer uma função que serializaria qualquer objeto em xml como este:

<string>content</string>

ou

<numeric>123.3</numeric>

ou gerar uma exceção.

Você simplesmente precisará fazer uma verificação de tipo para cada um dos tipos numéricos básicos.

Aqui está um método de extensão que deve fazer o trabalho:

public static bool IsNumber(this object value)
{
    return value is sbyte
            || value is byte
            || value is short
            || value is ushort
            || value is int
            || value is uint
            || value is long
            || value is ulong
            || value is float
            || value is double
            || value is decimal;
}

Isso deve abranger todos os tipos numéricos.

Atualizar

Parece que você realmente deseja analisar o número de uma string durante a desserialização. Nesse caso, provavelmente seria melhor usar double.TryParse.

string value = "123.3";
double num;
if (!double.TryParse(value, out num))
    throw new InvalidOperationException("Value is not a number.");

Claro, isso não lidaria com inteiros muito grandes / decimais longos, mas se for esse o caso, você só precisa adicionar chamadas para long.TryParse/ decimal.TryParse/ qualquer outra coisa.

Retirado do Blog de Scott Hanselman :

public static bool IsNumeric(object expression)
{
    if (expression == null)
    return false;

    double number;
    return Double.TryParse( Convert.ToString( expression
                                            , CultureInfo.InvariantCulture)
                          , System.Globalization.NumberStyles.Any
                          , NumberFormatInfo.InvariantInfo
                          , out number);
}

Aproveite a propriedade IsPrimitive para fazer um método de extensão útil:

public static bool IsNumber(this object obj)
{
    if (Equals(obj, null))
    {
        return false;
    }

    Type objType = obj.GetType();
    objType = Nullable.GetUnderlyingType(objType) ?? objType;

    if (objType.IsPrimitive)
    {
        return objType != typeof(bool) && 
            objType != typeof(char) && 
            objType != typeof(IntPtr) && 
            objType != typeof(UIntPtr);
    }

    return objType == typeof(decimal);
}

EDIT: Corrigido de acordo com comentários. Os genéricos foram removidos desde as caixas .GetType () tipos de valor. Também inclui correção para valores anuláveis.

Existem algumas ótimas respostas acima. Aqui está uma solução tudo-em-um. Três sobrecargas para diferentes circunstâncias.

// Extension method, call for any object, eg "if (x.IsNumeric())..."
public static bool IsNumeric(this object x) { return (x==null ? false : IsNumeric(x.GetType())); }

// Method where you know the type of the object
public static bool IsNumeric(Type type) { return IsNumeric(type, Type.GetTypeCode(type)); }

// Method where you know the type and the type code of the object
public static bool IsNumeric(Type type, TypeCode typeCode) { return (typeCode == TypeCode.Decimal || (type.IsPrimitive && typeCode != TypeCode.Object && typeCode != TypeCode.Boolean && typeCode != TypeCode.Char)); }

Em vez de lançar o seu próprio, a maneira mais confiável de saber se um tipo embutido é numérico é provavelmente referenciar Microsoft.VisualBasice chamar Information.IsNumeric(object value). A implementação lida com vários casos sutis, como char[]strings HEX e OCT.

Existem três conceitos diferentes lá:

• para verificar se é um número (ou seja, um valor numérico (normalmente em caixa) em si), verifique o tipo com is- por exemploif(obj is int) {...}
• para verificar se uma string pode ser analisada como um número; usarTryParse()
• mas se o objeto não for um número ou uma string, mas você suspeitar que ToString()pode fornecer algo que se pareça com um número, ligue ToString() e trate-o como uma string

Nos dois primeiros casos, você provavelmente terá que lidar separadamente com cada tipo numérico que deseja oferecer suporte ( double/ decimal/ int) - cada um tem diferentes intervalos e precisão, por exemplo.

Você também pode consultar o regex para uma verificação geral rápida.

Supondo que sua entrada seja uma string ...

Existem 2 maneiras:

use Double.ExperimenteParse ()

double temp;
bool isNumber = Double.TryParse(input, out temp);

usar Regex

 bool isNumber = Regex.IsMatch(input,@"-?\d+(\.\d+)?");

Você pode usar um código como este:

if (n is IConvertible)
  return ((IConvertible) n).ToDouble(CultureInfo.CurrentCulture);
else
  // Cannot be converted.

Se o objeto é um Int32, Single, Doubleetc, irá efectuar a conversão. Além disso, uma string implementa, IConvertiblemas se a string não for conversível em um duplo, um FormatExceptionserá lançado.

Se sua exigência é realmente

.ToString () resultaria em uma string contendo dígitos e +, - ,.

e você deseja usar double.ExperimenteParse, então você precisa usar a sobrecarga que leva um parâmetro NumberStyles e certifique-se de que está usando a cultura invariável.

Por exemplo, para um número que pode ter um sinal à esquerda, nenhum espaço em branco à esquerda ou à direita, nenhum separador de milhar e um separador decimal de ponto, use:

NumberStyles style = 
   NumberStyles.AllowLeadingSign | 
   NumberStyles.AllowDecimalPoint | 
double.TryParse(input, style, CultureInfo.InvariantCulture, out result);

Ao escrever meu próprio object.IsNumeric()método de extensão com base na resposta de Saul Dolgin a esta pergunta, encontrei um problema potencial em que você obterá um OverflowExceptionse tentar com double.MaxValueoudouble.MinValue .

Minha "solução" foi combinar a resposta aceita de noldorin com a de Saul Dolgin e adicionar uma chave de correspondência de padrões antes de tentar analisar qualquer coisa (e usar alguns recursos do C # 7 para arrumar um pouco):

public static bool IsNumeric(this object obj)
{
    if (obj == null) return false;

    switch (obj)
    {
        case sbyte _: return true;
        case byte _: return true;
        case short _: return true;
        case ushort _: return true;
        case int _: return true;
        case uint _: return true;
        case long _: return true;
        case ulong _: return true;
        case float _: return true;
        case double _: return true;
        case decimal _: return true;
    }

    string s = Convert.ToString(obj, CultureInfo.InvariantCulture);

    return double.TryParse(s, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out double _);
}

Sim, isso funciona:

object x = 1;
Assert.That(x is int);

Para um número de ponto flutuante, você teria que testar usando o tipo flutuante:

object x = 1f;
Assert.That(x is float);