संपादित करें

इसके माध्यम से साझा किया गया

Char.TryParse(String, Char) Method

  • Reference

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
Char.cs
Source:
Char.cs
Source:
Char.cs

Converts the value of the specified string to its equivalent Unicode character. A return code indicates whether the conversion succeeded or failed.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] char % result);
public static bool TryParse (string s, out char result);
public static bool TryParse (string? s, out char result);
static member TryParse : string * char -> bool
Public Shared Function TryParse (s As String, ByRef result As Char) As Boolean

Parameters

s
String

A string that contains a single character, or null.

result
Char

When this method returns, contains a Unicode character equivalent to the sole character in s, if the conversion succeeded, or an undefined value if the conversion failed. The conversion fails if the s parameter is null or the length of s is not 1. This parameter is passed uninitialized.

Returns

Boolean

true if the s parameter was converted successfully; otherwise, false.

Examples

The following code example demonstrates overloads of the TryParse method for several base types, and the TryParseExact method for the DateTime base type.

// 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 namespace System;
using namespace System::Globalization;

static void Show( bool parseResult, String^ typeName, String^ parseValue )
{
   String^ msgSuccess = L"Parse for {0} = {1}";
   String^ msgFailure = L"** Parse for {0} failed. Invalid input.";
   
   //
   if ( parseResult == true )
      Console::WriteLine( msgSuccess, typeName, parseValue );
   else
      Console::WriteLine( msgFailure, typeName );
}

void main()
{
   bool result;
   CultureInfo^ ci;
   String^ nl = Environment::NewLine;
   String^ msg1 = L"This example demonstrates overloads of the TryParse method for{0}"
   L"several base types, as well as the TryParseExact method for DateTime.{0}";
   String^ msg2 = L"Non-numeric types:{0}";
   String^ msg3 = L"{0}Numeric types:{0}";
   String^ msg4 = L"{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( L"7/4/2004 12:34:56",  datetimeVal );
   Show( result, L"DateTime #1", datetimeVal.ToString() );
   
   // Use fr-FR culture, and dates of the form: DDMMYYYY.
   ci = gcnew CultureInfo( L"fr-FR" );
   result = DateTime::TryParse( L"4/7/2004 12:34:56", ci, DateTimeStyles::None,  datetimeVal );
   Show( result, L"DateTime #2", datetimeVal.ToString() );
   
   // TryParseExact:
   // Use fr-FR culture. The format, "G", is short date and long time.
   result = DateTime::TryParseExact( L"04/07/2004 12:34:56", L"G", ci, DateTimeStyles::None,  datetimeVal );
   Show( result, L"DateTime #3", datetimeVal.ToString() );
   
   // Assume en-US culture.
   array<String^>^dateFormats = {L"f",L"F",L"g",L"G"};
   result = DateTime::TryParseExact( L"7/4/2004 12:34:56 PM", dateFormats, nullptr, DateTimeStyles::None,  datetimeVal );
   Show( result, L"DateTime #4", datetimeVal.ToString() );
   Console::WriteLine();
   
   // Boolean
   result = Boolean::TryParse( L"true",  booleanVal );
   Show( result, L"Boolean", booleanVal.ToString() );
   
   // Char
   result = Char::TryParse( L"A",  charVal );
   Show( result, L"Char", charVal.ToString() );
   
   // Numeric types:
   Console::WriteLine( msg3, nl );
   
   // Byte
   result = Byte::TryParse( L"1", NumberStyles::Integer, nullptr,  byteVal );
   Show( result, L"Byte", byteVal.ToString() );
   
   // Int16
   result = Int16::TryParse( L"-2", NumberStyles::Integer, nullptr,  int16Val );
   Show( result, L"Int16", int16Val.ToString() );
   
   // Int32
   result = Int32::TryParse( L"3", NumberStyles::Integer, nullptr,  int32Val );
   Show( result, L"Int32", int32Val.ToString() );
   
   // Int64
   result = Int64::TryParse( L"4", NumberStyles::Integer, nullptr,  int64Val );
   Show( result, L"Int64", int64Val.ToString() );
   
   // Decimal
   result = Decimal::TryParse( L"-5.5", NumberStyles::Number, nullptr,  decimalVal );
   Show( result, L"Decimal", decimalVal.ToString() );
   
   // Single
   result = Single::TryParse( L"6.6", static_cast<NumberStyles>((NumberStyles::Float | NumberStyles::AllowThousands)), nullptr,  singleVal );
   Show( result, L"Single", singleVal.ToString() );
   
   // Double
   result = Double::TryParse( L"-7", static_cast<NumberStyles>(NumberStyles::Float | NumberStyles::AllowThousands), nullptr,  doubleVal );
   Show( result, L"Double", doubleVal.ToString() );
   
   // Use the simple Double.TryParse overload, but specify an invalid value.
   result = Double::TryParse( L"abc",  doubleVal );
   Show( result, L"Double #2", doubleVal.ToString() );
   
   //
   Console::WriteLine( msg4, nl );
   
   // SByte
   result = SByte::TryParse( L"-8", NumberStyles::Integer, nullptr,  sbyteVal );
   Show( result, L"SByte", sbyteVal.ToString() );
   
   // UInt16
   result = UInt16::TryParse( L"9", NumberStyles::Integer, nullptr,  uint16Val );
   Show( result, L"UInt16", uint16Val.ToString() );
   
   // UInt32
   result = UInt32::TryParse( L"10", NumberStyles::Integer, nullptr,  uint32Val );
   Show( result, L"UInt32", uint32Val.ToString() );
   
   // UInt64
   result = UInt64::TryParse( L"11", NumberStyles::Integer, nullptr,  uint64Val );
   Show( result, L"UInt64", uint64Val.ToString() );
}

/*
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.

using System;
using System.Globalization;

class Sample
{
    public static void Main()
    {
    bool     success;
    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.
    success = DateTime.TryParse("7/4/2004 12:34:56", out datetimeVal);
    Show(success, "DateTime #1", datetimeVal.ToString());

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

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

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

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

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

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

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

    protected static void Show(bool parseSuccess, string typeName,
                               string parseValue)
    {
    string msgSuccess = "Parse for {0} = {1}";
    string msgFailure = "** Parse for {0} failed. Invalid input.";
//
    if (parseSuccess == 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.

open System
open System.Globalization

let show parseSuccess typeName parseValue =
    if parseSuccess then
        printfn $"Parse for %s{typeName} = %s{parseValue}"
    else
        printfn $"** Parse for %s{typeName} failed. Invalid input."

[<EntryPoint>]
let main _ =
    printfn "This example demonstrates overloads of the TryParse method for\nseveral base types, as well as the TryParseExact method for DateTime.\n"

// Non-numeric types:
    printfn "Non-numeric types:\n"
// DateTime
  // TryParse:
    // Assume current culture is en-US, and dates of the form: MMDDYYYY.
    let success, datetimeVal = DateTime.TryParse "7/4/2004 12:34:56"
    show success "DateTime #1" (string datetimeVal)

    // Use fr-FR culture, and dates of the form: DDMMYYYY.
    let ci = CultureInfo "fr-FR"
    let success, datetimeVal = DateTime.TryParse("4/7/2004 12:34:56", ci, DateTimeStyles.None)
    show success "DateTime #2" (string datetimeVal)

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

    // Assume en-US culture.
    let dateFormats = [| "f"; "F"; "g"; "G" |]
    let success, datetimeVal = DateTime.TryParseExact("7/4/2004 12:34:56 PM", dateFormats, null, DateTimeStyles.None)
    show success "DateTime #4" (string datetimeVal)

    printfn ""
// Boolean
    let success, booleanVal = Boolean.TryParse "true"
    show success "Boolean" (string booleanVal)
// Char
    let success, charVal = Char.TryParse "A"
    show success "Char" (string charVal)

// Numeric types:
    printfn "\nNumeric types:\n"
// Byte
    let success, byteVal = Byte.TryParse("1", NumberStyles.Integer, null)
    show success "Byte" (string byteVal)
// Int16
    let success, int16Val = Int16.TryParse("-2", NumberStyles.Integer, null)
    show success "Int16" (string int16Val)
// Int32
    let success, int32Val = Int32.TryParse("3", NumberStyles.Integer, null)
    show success "Int32" (string int32Val)
// Int64
    let success, int64Val = Int64.TryParse("4", NumberStyles.Integer, null)
    show success "Int64" (string int64Val)
// Decimal
    let success, decimalVal = Decimal.TryParse("-5.5", NumberStyles.Number, null)
    show success "Decimal" (string decimalVal)
// Single
    let success, singleVal = Single.TryParse("6.6", NumberStyles.Float ||| NumberStyles.AllowThousands, null)
    show success "Single" (string singleVal)
// Double
    let success, doubleVal = Double.TryParse("-7", NumberStyles.Float ||| NumberStyles.AllowThousands, null)
    show success "Double" (string doubleVal)

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

    let success, doubleVal = Double.TryParse "abc"
    show success "Double #2" (string doubleVal)
//
    printfn "\nThe following types are not CLS-compliant:\n"
// SByte
    let success, sbyteVal = SByte.TryParse("-8", NumberStyles.Integer, null)
    show success "SByte" (string sbyteVal)
// UInt16
    let success, uint16Val = UInt16.TryParse("9", NumberStyles.Integer, null)
    show success "UInt16" (string uint16Val)
// UInt32
    let success, uint32Val = UInt32.TryParse("10", NumberStyles.Integer, null)
    show success "UInt32" (string uint32Val)
// UInt64
    let success, uint64Val = UInt64.TryParse("11", NumberStyles.Integer, null)
    show success "UInt64" (string uint64Val)

    0

// 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
// Parse for DateTime #2 = 7/4/2004 12:34:56
// Parse for DateTime #3 = 7/4/2004 12:34:56
// Parse for DateTime #4 = 7/4/2004 12:34:56
//
// 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.

Imports System.Globalization

Class Sample
   Public Shared Sub Main()
      Dim result As Boolean
      Dim ci As CultureInfo
      Dim nl As String = Environment.NewLine
      Dim msg1 As String = _
                 "This example demonstrates overloads of the TryParse method for{0}" & _
                 "several base types, as well as the TryParseExact method for DateTime.{0}"
      Dim msg2 As String = "Non-numeric types:{0}"
      Dim msg3 As String = "{0}Numeric types:{0}"
      Dim msg4 As String = "{0}The following types are not CLS-compliant:{0}"
      
      ' Non-numeric types.
      Dim booleanVal As [Boolean]
      Dim charVal As [Char]
      Dim datetimeVal As DateTime
      
      ' Numeric types.
      Dim byteVal As [Byte]
      Dim int16Val As Int16
      Dim int32Val As Int32
      Dim int64Val As Int64
      Dim decimalVal As [Decimal]
      Dim singleVal As [Single]
      Dim doubleVal As [Double]
      
      ' The following types are not CLS-compliant.
      Dim sbyteVal As SByte
      Dim uint16Val As UInt16
      Dim uint32Val As UInt32
      Dim uint64Val As UInt64
      '
      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.
      Dim dateFormats As String() =  {"f", "F", "g", "G"}
      result = DateTime.TryParseExact("7/4/2004 12:34:56 PM", dateFormats, Nothing, DateTimeStyles.None, datetimeVal)
      Show(result, "DateTime #4", datetimeVal.ToString())
      
      Console.WriteLine()
      ' Boolean
      result = [Boolean].TryParse("true", booleanVal)
      Show(result, "Boolean", booleanVal.ToString())
      ' Char
      result = [Char].TryParse("A", charVal)
      Show(result, "Char", charVal.ToString())
      
      ' Numeric types:
      Console.WriteLine(msg3, nl)
      ' Byte
      result = [Byte].TryParse("1", NumberStyles.Integer, Nothing, byteVal)
      Show(result, "Byte", byteVal.ToString())
      ' Int16
      result = Int16.TryParse("-2", NumberStyles.Integer, Nothing, int16Val)
      Show(result, "Int16", int16Val.ToString())
      ' Int32
      result = Int32.TryParse("3", NumberStyles.Integer, Nothing, int32Val)
      Show(result, "Int32", int32Val.ToString())
      ' Int64
      result = Int64.TryParse("4", NumberStyles.Integer, Nothing, int64Val)
      Show(result, "Int64", int64Val.ToString())
      ' Decimal
      result = [Decimal].TryParse("-5.5", NumberStyles.Number, Nothing, decimalVal)
      Show(result, "Decimal", decimalVal.ToString())
      ' Single
      result = [Single].TryParse("6.6", NumberStyles.Float Or NumberStyles.AllowThousands, Nothing, singleVal)
      Show(result, "Single", singleVal.ToString())
      ' Double
      result = [Double].TryParse("-7", NumberStyles.Float Or NumberStyles.AllowThousands, Nothing, doubleVal)
      Show(result, "Double", doubleVal.ToString())
      
      ' Use the simple Double.TryParse overload, but specify an invalid value.
      result = [Double].TryParse("abc", doubleVal)
      Show(result, "Double #2", doubleVal.ToString())
      '
      Console.WriteLine(msg4, nl)
      ' SByte
      result = SByte.TryParse("-8", NumberStyles.Integer, Nothing, sbyteVal)
      Show(result, "SByte", sbyteVal.ToString())
      ' UInt16
      result = UInt16.TryParse("9", NumberStyles.Integer, Nothing, uint16Val)
      Show(result, "UInt16", uint16Val.ToString())
      ' UInt32
      result = UInt32.TryParse("10", NumberStyles.Integer, Nothing, uint32Val)
      Show(result, "UInt32", uint32Val.ToString())
      ' UInt64
      result = UInt64.TryParse("11", NumberStyles.Integer, Nothing, uint64Val)
      Show(result, "UInt64", uint64Val.ToString())
   End Sub
   
   
   Protected Shared Sub Show(parseResult As Boolean, typeName As String, parseValue As String)
      Dim msgSuccess As String = "Parse for {0} = {1}"
      Dim msgFailure As String = "** Parse for {0} failed. Invalid input."
      '
      If parseResult = True Then
         Console.WriteLine(msgSuccess, typeName, parseValue)
      Else
         Console.WriteLine(msgFailure, typeName)
      End If
   End Sub
End Class
'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
'

Remarks

The TryParse method is like the Parse method, except the TryParse method does not throw an exception if the conversion fails.

Applies to

See also