Esta documentación está archivada y no tiene mantenimiento.

UInt64.TryParse (Método) (String, NumberStyles, IFormatProvider, UInt64%)

Actualización: noviembre 2007

Convierte la representación en forma de cadena de un número en el estilo y en el formato específicos de la referencia cultural que se hayan especificado en el entero de 64 bits sin signo equivalente. Un valor devuelto indica si la conversión tuvo éxito o no.

Esta API no es compatible con CLS. La alternativa compatible con CLS es Parse(String).

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[CLSCompliantAttribute(false)]
public static bool TryParse(
	string s,
	NumberStyles style,
	IFormatProvider provider,
	out ulong result
)
/** @attribute CLSCompliantAttribute(false) */
public static boolean TryParse(
	String s,
	NumberStyles style,
	IFormatProvider provider,
	/** @attribute OutAttribute */ /** @ref */UInt64 result
)
public static function TryParse(
	s : String, 
	style : NumberStyles, 
	provider : IFormatProvider, 
	result : ulong
) : boolean

Parámetros

s
Tipo: System.String
Cadena que representa el número que se va a convertir.
style
Tipo: System.Globalization.NumberStyles
Combinación bit a bit de valores NumberStyles que indica el formato permitido de s. Un valor que se especifica de forma habitual es Integer.
provider
Tipo: System.IFormatProvider
Un objeto IFormatProvider que aporta información de formato específica de la referencia cultural acerca de s.
result
Tipo: System.UInt64%
El resultado de este método contiene el valor entero sin signo de 64 bits equivalente al número contenido en s si la conversión se realizó correctamente, o bien, cero si no se realizó correctamente. La conversión no se realiza correctamente si el parámetro s es null, no tiene un formato compatible con style o representa un número menor que MinValue o mayor que MaxValue. Este parámetro se pasa sin inicializar.

Valor devuelto

Tipo: System.Boolean
ES true si s se convirtió correctamente; en caso contrario, es false.

ExcepciónCondición
ArgumentException

style no es un valor de NumberStyles.

-O bien-

style no es una combinación de valores AllowHexSpecifier y HexNumber.

El método TryParse es como el método Parse, excepto que el método TryParse no produce ninguna excepción si se produce un error de conversión.

El parámetro s contiene un número compuesto de la siguiente forma:

[eb][signo]dígitos[eb]

O bien, si el parámetro style incluye AllowHexSpecifier:

[eb]dígitos hexadecimales[eb]

Los elementos que aparecen entre corchetes ([ y ]) son opcionales y el resto de elementos son como se indica a continuación.

eb

Espacio en blanco opcional si lo permite el objeto style.

signo

Signo opcional.

dígitos

Secuencia de dígitos de 0 a 9.

hexdigits

Secuencia de dígitos hexadecimales de 0 a f o de 0 a F.

El parámetro provider es un objeto IFormatProvider que obtiene un objeto NumberFormatInfo. El objeto NumberFormatInfo proporciona información específica de la referencia cultural acerca del formato de s. Si provider es null, se utiliza NumberFormatInfo de la actual referencia cultural.

En el ejemplo de código siguiente se muestran las sobrecargas del método TryParse para varios tipos base, así como el método DateTime.TryParseExact.

// This example demonstrates overloads of the TryParse method for
// several base types, and the TryParseExact method for DateTime.

// In most cases, this example uses the most complex overload; that is, the overload 
// with the most parameters for a particular type. If a complex overload specifies 
// null (Nothing in Visual Basic) for the IFormatProvider parameter, formatting 
// information is obtained from the culture associated with the current thread. 
// If a complex overload specifies the style parameter, the parameter value is 
// the default value used by the equivalent simple overload.

using System;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    bool     result;
    CultureInfo ci;
    string   nl = Environment.NewLine;
    string   msg1 = 
             "This example demonstrates overloads of the TryParse method for{0}" +
             "several base types, as well as the TryParseExact method for DateTime.{0}";
    string   msg2 = "Non-numeric types:{0}";
    string   msg3 = "{0}Numeric types:{0}";
    string   msg4 = "{0}The following types are not CLS-compliant:{0}";

// Non-numeric types.
    Boolean  booleanVal;
    Char     charVal;
    DateTime datetimeVal;

// Numeric types.
    Byte     byteVal;
    Int16    int16Val;
    Int32    int32Val;
    Int64    int64Val;
    Decimal  decimalVal;
    Single   singleVal;
    Double   doubleVal;

// The following types are not CLS-compliant.
    SByte    sbyteVal;
    UInt16   uint16Val;
    UInt32   uint32Val;
    UInt64   uint64Val;
//
    Console.WriteLine(msg1, nl);

// Non-numeric types:
    Console.WriteLine(msg2, nl);
// DateTime
  // TryParse:
    // Assume current culture is en-US, and dates of the form: MMDDYYYY.
    result = DateTime.TryParse("7/4/2004 12:34:56", out datetimeVal);
    Show(result, "DateTime #1", datetimeVal.ToString());

    // Use fr-FR culture, and dates of the form: DDMMYYYY.
    ci = new CultureInfo("fr-FR");
    result = DateTime.TryParse("4/7/2004 12:34:56", 
             ci, DateTimeStyles.None, out datetimeVal);
    Show(result, "DateTime #2", datetimeVal.ToString());

  // TryParseExact:
    // Use fr-FR culture. The format, "G", is short date and long time.
    result = DateTime.TryParseExact("04/07/2004 12:34:56", "G", 
             ci, DateTimeStyles.None, out datetimeVal);
    Show(result, "DateTime #3", datetimeVal.ToString());

    // Assume en-US culture.
    string[] dateFormats = {"f", "F", "g", "G"};
    result = DateTime.TryParseExact("7/4/2004 12:34:56 PM", 
             dateFormats, null, DateTimeStyles.None, 
             out datetimeVal);
    Show(result, "DateTime #4", datetimeVal.ToString());

    Console.WriteLine();
// Boolean
    result = Boolean.TryParse("true", out booleanVal);
    Show(result, "Boolean", booleanVal.ToString());
// Char
    result = Char.TryParse("A", out charVal);
    Show(result, "Char", charVal.ToString());

// Numeric types:
    Console.WriteLine(msg3, nl);
// Byte
    result = Byte.TryParse("1", NumberStyles.Integer, null, out byteVal);
    Show(result, "Byte", byteVal.ToString());
// Int16
    result = Int16.TryParse("-2", NumberStyles.Integer, null, out int16Val);
    Show(result, "Int16", int16Val.ToString());
// Int32
    result = Int32.TryParse("3", NumberStyles.Integer, null, out int32Val);
    Show(result, "Int32", int32Val.ToString());
// Int64
    result = Int64.TryParse("4", NumberStyles.Integer, null, out int64Val);
    Show(result, "Int64", int64Val.ToString());
// Decimal
    result = Decimal.TryParse("-5.5", NumberStyles.Number, null, out decimalVal);
    Show(result, "Decimal", decimalVal.ToString());
// Single
    result = Single.TryParse("6.6", 
             (NumberStyles.Float | NumberStyles.AllowThousands), 
             null, out singleVal);
    Show(result, "Single", singleVal.ToString());
// Double
    result = Double.TryParse("-7", 
             (NumberStyles.Float | NumberStyles.AllowThousands), 
             null, out doubleVal);
    Show(result, "Double", doubleVal.ToString());

// Use the simple Double.TryParse overload, but specify an invalid value.

    result = Double.TryParse("abc", out doubleVal);
    Show(result, "Double #2", doubleVal.ToString());
//
    Console.WriteLine(msg4, nl);
// SByte
    result = SByte.TryParse("-8", NumberStyles.Integer, null, out sbyteVal);
    Show(result, "SByte", sbyteVal.ToString());
// UInt16
    result = UInt16.TryParse("9", NumberStyles.Integer, null, out uint16Val);
    Show(result, "UInt16", uint16Val.ToString());
// UInt32
    result = UInt32.TryParse("10", NumberStyles.Integer, null, out uint32Val);
    Show(result, "UInt32", uint32Val.ToString());
// UInt64
    result = UInt64.TryParse("11", NumberStyles.Integer, null, out uint64Val);
    Show(result, "UInt64", uint64Val.ToString());
    }

    protected static void Show(bool parseResult, string typeName, 
                               string parseValue)
    {
    string msgSuccess = "Parse for {0} = {1}";
    string msgFailure = "** Parse for {0} failed. Invalid input.";
//
    if (parseResult == true)
        Console.WriteLine(msgSuccess, typeName, parseValue);
    else
        Console.WriteLine(msgFailure, typeName);
   }
}
/*
This example produces the following results:

This example demonstrates overloads of the TryParse method for
several base types, as well as the TryParseExact method for DateTime.

Non-numeric types:

Parse for DateTime #1 = 7/4/2004 12:34:56 PM
Parse for DateTime #2 = 7/4/2004 12:34:56 PM
Parse for DateTime #3 = 7/4/2004 12:34:56 PM
Parse for DateTime #4 = 7/4/2004 12:34:56 PM

Parse for Boolean = True
Parse for Char = A

Numeric types:

Parse for Byte = 1
Parse for Int16 = -2
Parse for Int32 = 3
Parse for Int64 = 4
Parse for Decimal = -5.5
Parse for Single = 6.6
Parse for Double = -7
** Parse for Double #2 failed. Invalid input.

The following types are not CLS-compliant:

Parse for SByte = -8
Parse for UInt16 = 9
Parse for UInt32 = 10
Parse for UInt64 = 11
*/


// This example demonstrates overloads of the TryParse method for
// several base types, and the TryParseExact method for DateTime.
// In most cases, this example uses the most complex overload; that is, 
// the overload with the most parameters for a particular type. If a 
// complex overload specifies null (Nothing in Visual Basic) for the 
// IFormatProvider parameter, formatting information is obtained from 
// the culture associated with the current thread. If a complex overload 
// specifies the style parameter, the parameter value is the default value 
// used by the equivalent simple overload.

import System.*;
import System.Globalization.*;

class Sample
{
    public static void main(String[] args)
    {
        boolean result;
        CultureInfo ci = null;
        String nl = Environment.get_NewLine();
        String msg1 = "This example demonstrates overloads of the TryParse " 
            + "method for{0}several base types, as well as the TryParseExact " 
            + "method for DateTime.{0}";
        String msg2 = "Non-numeric types:{0}";
        String msg3 = "{0}Numeric types:{0}";
        String msg4 = "{0}The following types are not CLS-compliant:{0}";
        // Non-numeric types.
        System.Boolean booleanVal = (System.Boolean)false;
        System.Char charVal = (System.Char)0;
        DateTime dateTimeVal = System.DateTime.get_Now();
        // Numeric types.
        Byte byteVal = null;
        Int16 int16Val = (Int16)0;
        Int32 int32Val = (Int32)0;
        Int64 int64Val = (Int64)0;
        Decimal decimalVal = new Decimal(0);
        Single singleVal = (Single)0;
        //Double doubleVal = new Double(0);
        double doubleVal = 0;
        // The following types are not CLS-compliant.
        SByte sByteVal = (System.SByte)0;
        UInt16 uInt16Val = (UInt16)0;
        UInt32 uInt32Val = (UInt32)0;
        UInt64 uInt64Val = (UInt64)0;
        //
        Console.WriteLine(msg1, nl);
        // Non-numeric types:
        Console.WriteLine(msg2, nl);
        // DateTime
        // TryParse:
        // Assume current culture is en-US, and dates of the form: MMDDYYYY.
        result = DateTime.TryParse("7/4/2004 12:34:56", dateTimeVal);
        Show(result, "DateTime #1", dateTimeVal.ToString());
        // Use fr-FR culture, and dates of the form: DDMMYYYY.
        ci = new CultureInfo("fr-FR");
        result = DateTime.TryParse("4/7/2004 12:34:56", ci,
            DateTimeStyles.None, dateTimeVal);
        Show(result, "DateTime #2", dateTimeVal.ToString());
        // TryParseExact:
        // Use fr-FR culture. The format, "G", is short date and long time.
        result = DateTime.TryParseExact("04/07/2004 12:34:56", "G", ci, 
            DateTimeStyles.None, dateTimeVal);
        Show(result, "DateTime #3", dateTimeVal.ToString());
        // Assume en-US culture.
        String dateFormats[] =  { "f", "F", "g", "G" };
        result = DateTime.TryParseExact("7/4/2004 12:34:56 PM", dateFormats, 
            null, DateTimeStyles.None, dateTimeVal);
        Show(result, "DateTime #4", dateTimeVal.ToString());

        Console.WriteLine();
        // Boolean
        boolean tempBooleanVal = System.Convert.ToBoolean(booleanVal);
        result = System.Boolean.TryParse("true",/**@out*/ tempBooleanVal);
        Show(result, "Boolean", System.Convert.ToString(tempBooleanVal));
        // Char
        char tempCharVal = System.Convert.ToChar(charVal);
        result = Char.TryParse("A", /**@out*/tempCharVal);
        Show(result, "Char", System.Convert.ToString(tempCharVal));
        // Numeric types:
        Console.WriteLine(msg3, nl);
        // Byte
        ubyte tempByteVal = System.Convert.ToByte(byteVal);
        result = System.Byte.TryParse("1", NumberStyles.Integer, null,
            /**@out*/tempByteVal);
        Show(result, "Byte", System.Convert.ToString(tempByteVal));
        // Int16
        short tempInt16Val = System.Convert.ToInt16(int16Val);
        result = Int16.TryParse("-2", NumberStyles.Integer, null,
            /**@out*/tempInt16Val);
        Show(result, "Int16", System.Convert.ToString(tempInt16Val));
        // Int32
        int tempInt32Val = System.Convert.ToInt32(int32Val);
        result = Int32.TryParse("3", NumberStyles.Integer, null,
            /**@out*/tempInt32Val);
        Show(result, "Int32", System.Convert.ToString(tempInt32Val));
        // Int64
        long tempInt64Val = System.Convert.ToInt64(int64Val);
        result = Int64.TryParse("4", NumberStyles.Integer, null,
            /**@out*/tempInt64Val);
        Show(result, "Int64", System.Convert.ToString(tempInt64Val));
        // Decimal
        result = Decimal.TryParse("-5.5", NumberStyles.Number, null,
            /**@out*/decimalVal);
        Show(result, "Decimal", decimalVal.ToString());
        // Single
        float tempSingleVal = System.Convert.ToSingle(singleVal);
        result = Single.TryParse("6.6", NumberStyles.Float 
            | NumberStyles.AllowThousands, null, /**@out*/tempSingleVal);
        Show(result, "Single", System.Convert.ToString(tempSingleVal));
        // Double
        result = System.Double.TryParse("-7", NumberStyles.Float 
            | NumberStyles.AllowThousands, null, /**@out*/doubleVal);
        Show(result, "Double", System.Convert.ToString(doubleVal));
        // Use the simple Double.TryParse overload, but specify an invalid value.
        result = System.Double.TryParse("abc", doubleVal);
        Show(result, "Double #2", System.Convert.ToString(doubleVal));
        //
        Console.WriteLine(msg4, nl);
        // SByte
        byte tempSByteVal = System.Convert.ToSByte(sByteVal);
        result = SByte.TryParse("-8", NumberStyles.Integer, null,
            /**@out*/tempSByteVal);
        Show(result, "SByte", System.Convert.ToString(tempSByteVal));
        // UInt16
        result = UInt16.TryParse("9", NumberStyles.Integer, null,
            /**@out*/uInt16Val);
        Show(result, "UInt16", uInt16Val.ToString());
        // UInt32
        result = UInt32.TryParse("10", NumberStyles.Integer, null,
            /**@out*/uInt32Val);
        Show(result, "UInt32", uInt32Val.ToString());
        // UInt64
        result = UInt64.TryParse("11", NumberStyles.Integer, null,
            /**@out*/uInt64Val);
        Show(result, "UInt64", uInt64Val.ToString());
    } //main

    protected static void Show(boolean parseResult,
        String typeName, String parseValue)
    {
        String msgSuccess = "Parse for {0} = {1}";
        String msgFailure = "** Parse for {0} failed. Invalid input.";
        //
        if (parseResult == true) {
            Console.WriteLine(msgSuccess, typeName, parseValue);
        }
        else {
            Console.WriteLine(msgFailure, typeName);
        }
    } //Show
} //Sample 
 /*
This example produces the following results:

This example demonstrates overloads of the TryParse method for
several base types, as well as the TryParseExact method for DateTime.

Non-numeric types:

Parse for DateTime #1 = 7/4/2004 12:34:56 PM
Parse for DateTime #2 = 7/4/2004 12:34:56 PM
Parse for DateTime #3 = 7/4/2004 12:34:56 PM
Parse for DateTime #4 = 7/4/2004 12:34:56 PM

Parse for Boolean = True
Parse for Char = A

Numeric types:

Parse for Byte = 1
Parse for Int16 = -2
Parse for Int32 = 3
Parse for Int64 = 4
Parse for Decimal = -5.5
Parse for Single = 6.6
Parse for Double = -7
** Parse for Double #2 failed. Invalid input.

The following types are not CLS-compliant:

Parse for SByte = -8
Parse for UInt16 = 9
Parse for UInt32 = 10
Parse for UInt64 = 11
*/


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0
Mostrar: