Export (0) Print
Expand All

TimeSpan.Parse Method

Constructs a TimeSpan from a time indicated by a specified string.

[Visual Basic]
Public Shared Function Parse( _
   ByVal s As String _
) As TimeSpan
[C#]
public static TimeSpan Parse(
 string s
);
[C++]
public: static TimeSpan Parse(
 String* s
);
[JScript]
public static function Parse(
   s : String
) : TimeSpan;

Parameters

s
A string.

Return Value

A TimeSpan that corresponds to s.

Exceptions

Exception Type Condition
ArgumentNullException s is a null reference (Nothing in Visual Basic).
FormatException s has an invalid format.
OverflowException s represents a number less than MinValue or greater than MaxValue.

-or-

At least one of the hours, minutes, or seconds components is outside its valid range.

Remarks

The s parameter contains a specification of the form:

[ws][-][d.]hh:mm:ss[.ff][ws]

Items in square brackets ([ and ]) are optional, colons and periods (: and .) are literal characters, and other items are as follows.

Item Description
ws optional white space
"-" optional minus sign indicating a negative time
"d" optional days
"hh" hours, ranging from 0 to 23
"mm" minutes, ranging from 0 to 59
"ss" seconds, ranging from 0 to 59
"ff" optional fractional seconds, from 1 to 7 decimal digits

Example

[Visual Basic, C#, C++] The following code example uses the Parse method to create TimeSpan objects from valid TimeSpan strings and to raise exceptions from invalid TimeSpan strings.

[Visual Basic] 
' Example of the TimeSpan.Parse( String ) and TimeSpan.ToString( ) 
' methods.
Imports System
Imports Microsoft.VisualBasic

Module TSParseToStringDemo

    Sub ParseNDisplayTimeSpan( intervalStr As String )

        ' Write the first part of the output line.
        Console.Write( "{0,20}   ", intervalStr )

        ' Parse the parameter, and then convert it back to a string.
        Try
            Dim intervalVal As TimeSpan = TimeSpan.Parse( intervalStr )
            Dim intervalToStr As String = intervalVal.ToString( )

            ' Pad the end of the TimeSpan string with spaces if it 
            ' does not contain milliseconds.
            Dim pIndex As Integer = intervalToStr.IndexOf( ":"c )
            pIndex = intervalToStr.IndexOf( "."c, pIndex )
            If pIndex < 0 Then   intervalToStr &= "        "

            Console.WriteLine( "{0,21}", intervalToStr )

        ' If Parse throws an exception, write the message.
        Catch ex As Exception
            Console.WriteLine( ex.Message )
        End Try
    End Sub 

    Sub Main( )

        Console.WriteLine( _
            "This example of TimeSpan.Parse( String ) and " & _
            vbCrLf & "TimeSpan.ToString( ) " & _
            "generates the following output." & vbCrLf )
        Console.WriteLine( "{0,20}   {1,21}", _
            "String to Parse", "TimeSpan or Exception" )    
        Console.WriteLine( "{0,20}   {1,21}", _
            "---------------", "---------------------" )    

        ParseNDisplayTimeSpan( "0" )
        ParseNDisplayTimeSpan( "14" )
        ParseNDisplayTimeSpan( "1:2:3" )
        ParseNDisplayTimeSpan( "0:0:0.250" )
        ParseNDisplayTimeSpan( "10.20:30:40.50" )
        ParseNDisplayTimeSpan( "99.23:59:59.9999999" )
        ParseNDisplayTimeSpan( "0023:0059:0059.0099" )
        ParseNDisplayTimeSpan( "24:0:0" )
        ParseNDisplayTimeSpan( "0:60:0" )
        ParseNDisplayTimeSpan( "0:0:60" )
        ParseNDisplayTimeSpan( "10:" )
        ParseNDisplayTimeSpan( ":10" )
        ParseNDisplayTimeSpan( "10:20:" )
        ParseNDisplayTimeSpan( ".123" )
        ParseNDisplayTimeSpan( "10." )
        ParseNDisplayTimeSpan( "10.12" )
    End Sub 
End Module 

' This example of TimeSpan.Parse( String ) and
' TimeSpan.ToString( ) generates the following output.
' 
'      String to Parse   TimeSpan or Exception
'      ---------------   ---------------------
'                    0        00:00:00
'                   14     14.00:00:00
'                1:2:3        01:02:03
'            0:0:0.250        00:00:00.2500000
'       10.20:30:40.50     10.20:30:40.5000000
'  99.23:59:59.9999999     99.23:59:59.9999999
'  0023:0059:0059.0099        23:59:59.0099000
'               24:0:0   TimeSpan overflowed because the duration is too long.
'               0:60:0   TimeSpan overflowed because the duration is too long.
'               0:0:60   TimeSpan overflowed because the duration is too long.
'                  10:   Input string was not in a correct format.
'                  :10   Input string was not in a correct format.
'               10:20:   Input string was not in a correct format.
'                 .123   Input string was not in a correct format.
'                  10.   Input string was not in a correct format.
'                10.12   Input string was not in a correct format.

[C#] 
// Example of the TimeSpan.Parse( string ) and TimeSpan.ToString( ) 
// methods.
using System;

class TSParseToStringDemo
{
    static void ParseNDisplayTimeSpan( string intervalStr )
    {
        // Write the first part of the output line.
        Console.Write( "{0,20}   ", intervalStr );

        // Parse the parameter, and then convert it back to a string.
        try
        {
            TimeSpan intervalVal = TimeSpan.Parse( intervalStr );
            string   intervalToStr = intervalVal.ToString( );

            // Pad the end of the TimeSpan string with spaces if it 
            // does not contain milliseconds.
            int pIndex = intervalToStr.IndexOf( ':' );
            pIndex = intervalToStr.IndexOf( '.', pIndex );
            if( pIndex < 0 )   intervalToStr += "        ";

            Console.WriteLine( "{0,21}", intervalToStr );
        }
        catch( Exception ex )
        {
            // If Parse throws an exception, write the message.
            Console.WriteLine( ex.Message );
        }
    } 

    static void Main( )
    {
        Console.WriteLine(
            "This example of TimeSpan.Parse( string ) and \n" +
            "TimeSpan.ToString( ) " +
            "generates the following output.\n" );
        Console.WriteLine( "{0,20}   {1,21}", 
            "String to Parse", "TimeSpan or Exception" );
        Console.WriteLine( "{0,20}   {1,21}", 
            "---------------", "---------------------" );

        ParseNDisplayTimeSpan( "0" );
        ParseNDisplayTimeSpan( "14" );
        ParseNDisplayTimeSpan( "1:2:3" );
        ParseNDisplayTimeSpan( "0:0:0.250" );
        ParseNDisplayTimeSpan( "10.20:30:40.50" );
        ParseNDisplayTimeSpan( "99.23:59:59.9999999" );
        ParseNDisplayTimeSpan( "0023:0059:0059.0099" );
        ParseNDisplayTimeSpan( "24:0:0" );
        ParseNDisplayTimeSpan( "0:60:0" );
        ParseNDisplayTimeSpan( "0:0:60" );
        ParseNDisplayTimeSpan( "10:" );
        ParseNDisplayTimeSpan( ":10" );
        ParseNDisplayTimeSpan( "10:20:" );
        ParseNDisplayTimeSpan( ".123" );
        ParseNDisplayTimeSpan( "10." );
        ParseNDisplayTimeSpan( "10.12" );
    } 
} 

/*
This example of TimeSpan.Parse( string ) and
TimeSpan.ToString( ) generates the following output.

     String to Parse   TimeSpan or Exception
     ---------------   ---------------------
                   0        00:00:00
                  14     14.00:00:00
               1:2:3        01:02:03
           0:0:0.250        00:00:00.2500000
      10.20:30:40.50     10.20:30:40.5000000
 99.23:59:59.9999999     99.23:59:59.9999999
 0023:0059:0059.0099        23:59:59.0099000
              24:0:0   TimeSpan overflowed because the duration is too long.
              0:60:0   TimeSpan overflowed because the duration is too long.
              0:0:60   TimeSpan overflowed because the duration is too long.
                 10:   Input string was not in a correct format.
                 :10   Input string was not in a correct format.
              10:20:   Input string was not in a correct format.
                .123   Input string was not in a correct format.
                 10.   Input string was not in a correct format.
               10.12   Input string was not in a correct format.
*/ 

[C++] 
// Example of the TimeSpan::Parse( String* ) and TimeSpan::ToString( ) 
// methods.
#using <mscorlib.dll>
using namespace System;

void ParseNDisplayTimeSpan( String* intervalStr )
{
    // Write the first part of the output line.
    Console::Write( S"{0,20}   ", intervalStr );

    // Parse the parameter, and then convert it back to a string.
    try
    {
        TimeSpan intervalVal = TimeSpan::Parse( intervalStr );
        String*  intervalToStr = intervalVal.ToString( );

        // Pad the end of the TimeSpan string with spaces if it 
        // does not contain milliseconds.
        int pIndex = intervalToStr->IndexOf( ':' );
        pIndex = intervalToStr->IndexOf( '.', pIndex );
        if( pIndex < 0 )   intervalToStr = 
            String::Concat( intervalToStr, S"        " );

        Console::WriteLine( S"{0,21}", intervalToStr );
    }
    catch( Exception* ex )
    {
        // If Parse throws an exception, write the message.
        Console::WriteLine( ex->Message );
    }
} 

void main( )
{
    Console::WriteLine(
        S"This example of TimeSpan::Parse( String* ) and \n" 
        S"TimeSpan::ToString( ) " 
        S"generates the following output.\n" );
    Console::WriteLine( S"{0,20}   {1,21}", 
        S"String to Parse", S"TimeSpan or Exception" );
    Console::WriteLine( S"{0,20}   {1,21}", 
        S"---------------", S"---------------------" );

    ParseNDisplayTimeSpan( S"0" );
    ParseNDisplayTimeSpan( S"14" );
    ParseNDisplayTimeSpan( S"1:2:3" );
    ParseNDisplayTimeSpan( S"0:0:0.250" );
    ParseNDisplayTimeSpan( S"10.20:30:40.50" );
    ParseNDisplayTimeSpan( S"99.23:59:59.9999999" );
    ParseNDisplayTimeSpan( S"0023:0059:0059.0099" );
    ParseNDisplayTimeSpan( S"24:0:0" );
    ParseNDisplayTimeSpan( S"0:60:0" );
    ParseNDisplayTimeSpan( S"0:0:60" );
    ParseNDisplayTimeSpan( S"10:" );
    ParseNDisplayTimeSpan( S":10" );
    ParseNDisplayTimeSpan( S"10:20:" );
    ParseNDisplayTimeSpan( S".123" );
    ParseNDisplayTimeSpan( S"10." );
    ParseNDisplayTimeSpan( S"10.12" );
}

/*
This example of TimeSpan::Parse( String* ) and
TimeSpan::ToString( ) generates the following output.

     String to Parse   TimeSpan or Exception
     ---------------   ---------------------
                   0        00:00:00
                  14     14.00:00:00
               1:2:3        01:02:03
           0:0:0.250        00:00:00.2500000
      10.20:30:40.50     10.20:30:40.5000000
 99.23:59:59.9999999     99.23:59:59.9999999
 0023:0059:0059.0099        23:59:59.0099000
              24:0:0   TimeSpan overflowed because the duration is too long.
              0:60:0   TimeSpan overflowed because the duration is too long.
              0:0:60   TimeSpan overflowed because the duration is too long.
                 10:   Input string was not in a correct format.
                 :10   Input string was not in a correct format.
              10:20:   Input string was not in a correct format.
                .123   Input string was not in a correct format.
                 10.   Input string was not in a correct format.
               10.12   Input string was not in a correct format.
*/ 

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework, Common Language Infrastructure (CLI) Standard

See Also

TimeSpan Structure | TimeSpan Members | System Namespace | String | ToString

Show:
© 2014 Microsoft