Export (0) Print
Expand All

TimeSpan Unary Plus Operator

Returns the specified instance of TimeSpan.

[Visual Basic]
returnValue = TimeSpan.op_UnaryPlus(t)
[C#]
public static TimeSpan operator +(
 TimeSpan t
);
[C++]
public: static TimeSpan op_UnaryPlus(
 TimeSpan t
);
[JScript]
returnValue = +t;

[Visual Basic] In Visual Basic, you can use the operators defined by a type, but you cannot define your own.

[JScript] In JScript, you can use the operators defined by a type, but you cannot define your own.

Arguments [Visual Basic, JScript]

t
A TimeSpan.

Parameters [C#, C++]

t
A TimeSpan.

Return Value

Returns t.

Example

[Visual Basic, C#, C++] The following code example applies the Unary Plus operator to several TimeSpan objects.

[Visual Basic] 
' Example of the TimeSpan.Duration( ) and TimeSpan.Negate( ) methods,
' and the TimeSpan Unary Negation and Unary Plus operators.
Imports System
Imports Microsoft.VisualBasic

Module DuraNegaUnaryDemo

    Const dataFmt As String = "{0,22}{1,22}{2,22}"

    Sub ShowDurationNegate( interval As TimeSpan )

        ' Display the TimeSpan value and the results of the 
        ' Duration and Negate methods.
        Console.WriteLine( dataFmt, _
            interval, interval.Duration( ), interval.Negate( ) )
    End Sub

    Sub Main( )

        Console.WriteLine( _
            "This example of TimeSpan.Duration( ), " & _
            "TimeSpan.Negate( ), " & vbCrLf & _
            "and the TimeSpan Unary Negation and " & _
            "Unary Plus operators " & vbCrLf & _
            "generates the following output." & vbCrLf )
        Console.WriteLine( dataFmt, _
            "TimeSpan", "Duration( )", "Negate( )" )    
        Console.WriteLine( dataFmt, _
            "--------", "-----------", "---------" )    

        ' Create TimeSpan objects and apply the Unary Negation
        ' and Unary Plus operators to them.
        ShowDurationNegate( new TimeSpan( 1 ) )
        ShowDurationNegate( new TimeSpan( -1234567 ) )
        ShowDurationNegate( TimeSpan.op_UnaryPlus( _
            new TimeSpan( 0, 0, 10, -20, -30 ) ) )
        ShowDurationNegate( TimeSpan.op_UnaryPlus( _
            new TimeSpan( 0, -10, 20, -30, 40 ) ) )
        ShowDurationNegate( TimeSpan.op_UnaryNegation( _
            new TimeSpan( 1, 10, 20, 40, 160 ) ) )
        ShowDurationNegate( TimeSpan.op_UnaryNegation( _
            new TimeSpan( -10, -20, -30, -40, -50 ) ) )
    End Sub 
End Module 

' This example of TimeSpan.Duration( ), TimeSpan.Negate( ),
' and the TimeSpan Unary Negation and Unary Plus operators
' generates the following output.
' 
'               TimeSpan           Duration( )             Negate( )
'               --------           -----------             ---------
'       00:00:00.0000001      00:00:00.0000001     -00:00:00.0000001
'      -00:00:00.1234567      00:00:00.1234567      00:00:00.1234567
'       00:09:39.9700000      00:09:39.9700000     -00:09:39.9700000
'      -09:40:29.9600000      09:40:29.9600000      09:40:29.9600000
'    -1.10:20:40.1600000    1.10:20:40.1600000    1.10:20:40.1600000
'    10.20:30:40.0500000   10.20:30:40.0500000  -10.20:30:40.0500000

[C#] 
// Example of the TimeSpan.Duration( ) and TimeSpan.Negate( ) methods,
// and the TimeSpan Unary Negation and Unary Plus operators.
using System;

class DuraNegaUnaryDemo
{
    const string dataFmt = "{0,22}{1,22}{2,22}" ;

    static void ShowDurationNegate( TimeSpan interval )
    {
        // Display the TimeSpan value and the results of the 
        // Duration and Negate methods.
        Console.WriteLine( dataFmt, 
            interval, interval.Duration( ), interval.Negate( ) );
    }

    static void Main()
    {
        Console.WriteLine(
            "This example of TimeSpan.Duration( ), " +
            "TimeSpan.Negate( ), \nand the TimeSpan Unary " +
            "Negation and Unary Plus operators \n" +
            "generates the following output.\n" );
        Console.WriteLine( dataFmt, 
            "TimeSpan", "Duration( )", "Negate( )" );
        Console.WriteLine( dataFmt, 
            "--------", "-----------", "---------" );

        // Create TimeSpan objects and apply the Unary Negation
        // and Unary Plus operators to them.
        ShowDurationNegate( new TimeSpan( 1 ) );
        ShowDurationNegate( new TimeSpan( -1234567 ) );
        ShowDurationNegate( 
            + new TimeSpan( 0, 0, 10, -20, -30 ) );
        ShowDurationNegate( 
            + new TimeSpan( 0, -10, 20, -30, 40 ) );
        ShowDurationNegate( 
            - new TimeSpan( 1, 10, 20, 40, 160 ) );
        ShowDurationNegate( 
            - new TimeSpan( -10, -20, -30, -40, -50 ) );
    } 
} 

/*
This example of TimeSpan.Duration( ), TimeSpan.Negate( ),
and the TimeSpan Unary Negation and Unary Plus operators
generates the following output.

              TimeSpan           Duration( )             Negate( )
              --------           -----------             ---------
      00:00:00.0000001      00:00:00.0000001     -00:00:00.0000001
     -00:00:00.1234567      00:00:00.1234567      00:00:00.1234567
      00:09:39.9700000      00:09:39.9700000     -00:09:39.9700000
     -09:40:29.9600000      09:40:29.9600000      09:40:29.9600000
   -1.10:20:40.1600000    1.10:20:40.1600000    1.10:20:40.1600000
   10.20:30:40.0500000   10.20:30:40.0500000  -10.20:30:40.0500000
*/ 

[C++] 
// Example of the TimeSpan::Duration( ) and TimeSpan::Negate( ) methods,
// and the TimeSpan Unary Negation and Unary Plus operators.
#using <mscorlib.dll>
using namespace System;

const __wchar_t* protoFmt = L"{0,22}{1,22}{2,22}" ;

void ShowDurationNegate( TimeSpan interval )
{
    // Display the TimeSpan value and the results of the 
    // Duration and Negate methods.
    Console::WriteLine( new String( protoFmt ), 
        __box( interval ), __box( interval.Duration( ) ), 
        __box( interval.Negate( ) ) );
}

void main( )
{
    Console::WriteLine(
        S"This example of TimeSpan::Duration( ), " 
        S"TimeSpan::Negate( ), \nand the TimeSpan Unary " 
        S"Negation and Unary Plus operators \n" 
        S"generates the following output.\n" );
    Console::WriteLine( new String( protoFmt ), 
        S"TimeSpan", S"Duration( )", S"Negate( )" );
    Console::WriteLine( new String( protoFmt ), 
        S"--------", S"-----------", S"---------" );

    // Create TimeSpan objects and apply the Unary Negation
    // and Unary Plus operators to them.
    ShowDurationNegate( TimeSpan( 1 ) );
    ShowDurationNegate( TimeSpan( -1234567 ) );
    ShowDurationNegate( 
        + TimeSpan( 0, 0, 10, -20, -30 ) );
    ShowDurationNegate( 
        + TimeSpan( 0, -10, 20, -30, 40 ) );
    ShowDurationNegate( 
        - TimeSpan( 1, 10, 20, 40, 160 ) );
    ShowDurationNegate( 
        - TimeSpan( -10, -20, -30, -40, -50 ) );
} 

/*
This example of TimeSpan::Duration( ), TimeSpan::Negate( ),
and the TimeSpan Unary Negation and Unary Plus operators
generates the following output.

              TimeSpan           Duration( )             Negate( )
              --------           -----------             ---------
      00:00:00.0000001      00:00:00.0000001     -00:00:00.0000001
     -00:00:00.1234567      00:00:00.1234567      00:00:00.1234567
      00:09:39.9700000      00:09:39.9700000     -00:09:39.9700000
     -09:40:29.9600000      09:40:29.9600000      09:40:29.9600000
   -1.10:20:40.1600000    1.10:20:40.1600000    1.10:20:40.1600000
   10.20:30:40.0500000   10.20:30:40.0500000  -10.20:30:40.0500000
*/ 

[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, Common Language Infrastructure (CLI) Standard

See Also

TimeSpan Structure | TimeSpan Members | System Namespace

Show:
© 2014 Microsoft