Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
FromTicks Method

TimeSpan.FromTicks Method

Returns a TimeSpan that represents a specified time, where the specification is in units of ticks.

[Visual Basic]
Public Shared Function FromTicks( _
   ByVal value As Long _
) As TimeSpan
[C#]
public static TimeSpan FromTicks(
 long value
);
[C++]
public: static TimeSpan FromTicks(
 __int64 value
);
[JScript]
public static function FromTicks(
   value : long
) : TimeSpan;

Parameters

value
A number of ticks that represent a time.

Return Value

A TimeSpan with a value of value.

Remarks

This is a convenience method with the same behavior as the TimeSpan constructor.

Example

[Visual Basic, C#, C++] The following code example creates several TimeSpan objects using the FromTicks method.

[Visual Basic] 
' Example of the TimeSpan.FromTicks( Long ) method.
Imports System
Imports Microsoft.VisualBasic

Module FromTicksDemo

    Sub GenTimeSpanFromTicks( ticks As Long )

        ' Create a TimeSpan object and TimeSpan string from 
        ' a number of ticks.
        Dim interval As TimeSpan = TimeSpan.FromTicks( ticks )
        Dim timeInterval As String = interval.ToString( )

        ' Pad the end of the TimeSpan string with spaces if it 
        ' does not contain milliseconds.
        Dim pIndex As Integer = timeInterval.IndexOf( ":"c )
        pIndex = timeInterval.IndexOf( "."c, pIndex )
        If pIndex < 0 Then   timeInterval &= "        "
        
        Console.WriteLine( "{0,21}{1,26}", ticks, timeInterval )
    End Sub 

    Sub Main( )

        Console.WriteLine( _
            "This example of TimeSpan.FromTicks( Long )" & _
            vbCrLf & "generates the following output." & vbCrLf )
        Console.WriteLine( "{0,21}{1,18}", _
            "FromTicks", "TimeSpan" )    
        Console.WriteLine( "{0,21}{1,18}", _
            "---------", "--------" )    

        GenTimeSpanFromTicks( 1 )
        GenTimeSpanFromTicks( 12345 )
        GenTimeSpanFromTicks( 123456789 )
        GenTimeSpanFromTicks( 1234567898765 )
        GenTimeSpanFromTicks( 12345678987654321 )
        GenTimeSpanFromTicks( 10000000 )
        GenTimeSpanFromTicks( 600000000 )
        GenTimeSpanFromTicks( 36000000000 )
        GenTimeSpanFromTicks( 864000000000 )
        GenTimeSpanFromTicks( 18012202000000 )
    End Sub 
End Module 

' This example of TimeSpan.FromTicks( Long )
' generates the following output.
' 
'             FromTicks          TimeSpan
'             ---------          --------
'                     1          00:00:00.0000001
'                 12345          00:00:00.0012345
'             123456789          00:00:12.3456789
'         1234567898765        1.10:17:36.7898765
'     12345678987654321    14288.23:31:38.7654321
'              10000000          00:00:01
'             600000000          00:01:00
'           36000000000          01:00:00
'          864000000000        1.00:00:00
'        18012202000000       20.20:20:20.2000000

[C#] 
// Example of the TimeSpan.FromTicks( long ) method.
using System;

class FromTicksDemo
{
    static void GenTimeSpanFromTicks( long ticks )
    {
        // Create a TimeSpan object and TimeSpan string from 
        // a number of ticks.
        TimeSpan    interval = TimeSpan.FromTicks( ticks );
        string      timeInterval = interval.ToString( );

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

        Console.WriteLine( "{0,21}{1,26}", ticks, timeInterval );
    } 

    static void Main( )
    {
        Console.WriteLine(
            "This example of TimeSpan.FromTicks( long )\n" +
            "generates the following output.\n" );
        Console.WriteLine( "{0,21}{1,18}", 
            "FromTicks", "TimeSpan" );
        Console.WriteLine( "{0,21}{1,18}", 
            "---------", "--------" );

        GenTimeSpanFromTicks( 1 );
        GenTimeSpanFromTicks( 12345 );
        GenTimeSpanFromTicks( 123456789 );
        GenTimeSpanFromTicks( 1234567898765 );
        GenTimeSpanFromTicks( 12345678987654321 );
        GenTimeSpanFromTicks( 10000000 );
        GenTimeSpanFromTicks( 600000000 );
        GenTimeSpanFromTicks( 36000000000 );
        GenTimeSpanFromTicks( 864000000000 );
        GenTimeSpanFromTicks( 18012202000000 );
    } 
} 

/*
This example of TimeSpan.FromTicks( long )
generates the following output.

            FromTicks          TimeSpan
            ---------          --------
                    1          00:00:00.0000001
                12345          00:00:00.0012345
            123456789          00:00:12.3456789
        1234567898765        1.10:17:36.7898765
    12345678987654321    14288.23:31:38.7654321
             10000000          00:00:01
            600000000          00:01:00
          36000000000          01:00:00
         864000000000        1.00:00:00
       18012202000000       20.20:20:20.2000000
*/

[C++] 
// Example of the TimeSpan::FromTicks( __int64 ) method.
#using <mscorlib.dll>
using namespace System;

void GenTimeSpanFromTicks( __int64 ticks )
{
    // Create a TimeSpan object and TimeSpan string from 
    // a number of ticks.
    TimeSpan    interval = TimeSpan::FromTicks( ticks );
    String*     timeInterval = interval.ToString();

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

    Console::WriteLine( S"{0,21}{1,26}", __box( ticks ), 
        timeInterval );
} 

void main( )
{
    Console::WriteLine(
        S"This example of TimeSpan::FromTicks( __int64 )\n" 
        S"generates the following output.\n" );
    Console::WriteLine( S"{0,21}{1,18}", S"FromTicks", S"TimeSpan" );
    Console::WriteLine( S"{0,21}{1,18}", S"---------", S"--------" );

    GenTimeSpanFromTicks( 1 );
    GenTimeSpanFromTicks( 12345 );
    GenTimeSpanFromTicks( 123456789 );
    GenTimeSpanFromTicks( 1234567898765 );
    GenTimeSpanFromTicks( 12345678987654321 );
    GenTimeSpanFromTicks( 10000000 );
    GenTimeSpanFromTicks( 600000000 );
    GenTimeSpanFromTicks( 36000000000 );
    GenTimeSpanFromTicks( 864000000000 );
    GenTimeSpanFromTicks( 18012202000000 );
} 

/*
This example of TimeSpan::FromTicks( __int64 )
generates the following output.

            FromTicks          TimeSpan
            ---------          --------
                    1          00:00:00.0000001
                12345          00:00:00.0012345
            123456789          00:00:12.3456789
        1234567898765        1.10:17:36.7898765
    12345678987654321    14288.23:31:38.7654321
             10000000          00:00:01
            600000000          00:01:00
          36000000000          01:00:00
         864000000000        1.00:00:00
       18012202000000       20.20:20:20.2000000
*/

[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 | Int64 | FromMilliseconds | FromSeconds | FromMinutes | FromHours | FromDays

Show:
© 2015 Microsoft