数值的转换（Parse、TryParse）

 Byte

//Byte
public static byte Parse(String s)
{
    return Parse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}

public static byte Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Parse(s, style, NumberFormatInfo.CurrentInfo);
}

public static byte Parse(String s, IFormatProvider provider)
{
    return Parse(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}

public static byte Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Parse(s, style, NumberFormatInfo.GetInstance(provider));
}

private static byte Parse(String s, NumberStyles style, NumberFormatInfo info)
{
    int i = 0;
    try
    {
        i = Number.ParseInt32(s, style, info);
    }
    catch (OverflowException e)
    {
        throw new OverflowException(Environment.GetResourceString("Overflow_Byte"), e);
    }

    if (i < MinValue || i > MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
    return (byte)i;
}


public static bool TryParse(String s, out Byte result)
{
    return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}

public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Byte result)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

private static bool TryParse(String s, NumberStyles style, NumberFormatInfo info, out Byte result)
{
    result = 0;
    int i;
    if (!Number.TryParseInt32(s, style, info, out i))
    {
        return false;
    }
    if (i < MinValue || i > MaxValue)
    {
        return false;
    }
    result = (byte)i;
    return true;
}

 

Int16(short)

//Int16
public static short Parse(String s)
{
    return Parse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}

public static short Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Parse(s, style, NumberFormatInfo.CurrentInfo);
}

public static short Parse(String s, IFormatProvider provider)
{
    return Parse(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}

public static short Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Parse(s, style, NumberFormatInfo.GetInstance(provider));
}

private static short Parse(String s, NumberStyles style, NumberFormatInfo info)
{
    int i = 0;
    try
    {
        i = Number.ParseInt32(s, style, info);
    }
    catch (OverflowException e)
    {
        throw new OverflowException(Environment.GetResourceString("Overflow_Int16"), e);
    }

    if ((style & NumberStyles.AllowHexSpecifier) != 0)
    {
        if ((i < 0) || (i > UInt16.MaxValue))
        {
            throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
        }
        return (short)i;
    }

    if (i < MinValue || i > MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
    return (short)i;
}


public static bool TryParse(String s, out Int16 result)
{
    return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}

public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int16 result)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

private static bool TryParse(String s, NumberStyles style, NumberFormatInfo info, out Int16 result)
{
    result = 0;
    int i;
    if (!Number.TryParseInt32(s, style, info, out i))
    {
        return false;
    }

    if ((style & NumberStyles.AllowHexSpecifier) != 0)
    {
        if ((i < 0) || i > UInt16.MaxValue)
        {
            return false;
        }
        result = (Int16)i;
        return true;
    }

    if (i < MinValue || i > MaxValue)
    {
        return false;
    }
    result = (Int16)i;
    return true;
}

 

Int32

//Int32
public static int Parse(String s)
{
    return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}

public static int Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.ParseInt32(s, style, NumberFormatInfo.CurrentInfo);
}

public static int Parse(String s, IFormatProvider provider)
{
    return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}

public static int Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider));
}


public static bool TryParse(String s, out Int32 result)
{
    return Number.TryParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}

public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int32 result)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

 

Int64(long)

//Int64
public static long Parse(String s)
{
    return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}

public static long Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
}

public static long Parse(String s, IFormatProvider provider)
{
    return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}

public static long Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
}


public static Boolean TryParse(String s, out Int64 result)
{
    return Number.TryParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}

public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Int64 result)
{
    NumberFormatInfo.ValidateParseStyleInteger(style);
    return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

 

float(Single)  --[f,F]

//Single

public static float Parse(String s)
{
    return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
}

public static float Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Parse(s, style, NumberFormatInfo.CurrentInfo);
}

public static float Parse(String s, IFormatProvider provider)
{
    return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
}

public static float Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Parse(s, style, NumberFormatInfo.GetInstance(provider));
}

private static float Parse(String s, NumberStyles style, NumberFormatInfo info)
{
    return Number.ParseSingle(s, style, info);
}


public static Boolean TryParse(String s, out Single result)
{
    return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
}

public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Single result)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

private static Boolean TryParse(String s, NumberStyles style, NumberFormatInfo info, out Single result)
{
    if (s == null)
    {
        result = 0;
        return false;
    }
    bool success = Number.TryParseSingle(s, style, info, out result);
    if (!success)
    {
        String sTrim = s.Trim();
        if (sTrim.Equals(info.PositiveInfinitySymbol))
        {
            result = PositiveInfinity;
        }
        else if (sTrim.Equals(info.NegativeInfinitySymbol))
        {
            result = NegativeInfinity;
        }
        else if (sTrim.Equals(info.NaNSymbol))
        {
            result = NaN;
        }
        else
            return false; // We really failed
    }
    return true;
}

 

double  --[d,D]

//Double
public static double Parse(String s)
{
    return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
}

public static double Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Parse(s, style, NumberFormatInfo.CurrentInfo);
}

public static double Parse(String s, IFormatProvider provider)
{
    return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
}

public static double Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Parse(s, style, NumberFormatInfo.GetInstance(provider));
}

private static double Parse(String s, NumberStyles style, NumberFormatInfo info)
{
    return Number.ParseDouble(s, style, info);
}


public static bool TryParse(String s, out double result)
{
    return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
}

public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out double result)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}

private static bool TryParse(String s, NumberStyles style, NumberFormatInfo info, out double result)
{
    if (s == null)
    {
        result = 0;
        return false;
    }
    bool success = Number.TryParseDouble(s, style, info, out result);
    if (!success)
    {
        String sTrim = s.Trim();
        if (sTrim.Equals(info.PositiveInfinitySymbol))
        {
            result = PositiveInfinity;
        }
        else if (sTrim.Equals(info.NegativeInfinitySymbol))
        {
            result = NegativeInfinity;
        }
        else if (sTrim.Equals(info.NaNSymbol))
        {
            result = NaN;
        }
        else
            return false; // We really failed
    }
    return true;
}

 

decimal  --[m,M]

//Decimal
public static Decimal Parse(String s)
{
    return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo);
}

public static Decimal Parse(String s, NumberStyles style)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Number.ParseDecimal(s, style, NumberFormatInfo.CurrentInfo);
}

public static Decimal Parse(String s, IFormatProvider provider)
{
    return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.GetInstance(provider));
}

public static Decimal Parse(String s, NumberStyles style, IFormatProvider provider)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Number.ParseDecimal(s, style, NumberFormatInfo.GetInstance(provider));
}


public static Boolean TryParse(String s, out Decimal result)
{
    return Number.TryParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo, out result);
}

public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Decimal result)
{
    NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
    return Number.TryParseDecimal(s, style, NumberFormatInfo.GetInstance(provider), out result);
}