Export (0) Print
Expand All
This topic has not yet been rated - Rate this topic

TimeSpan Unary Negation Operator

Returns a TimeSpan whose value is the negated value of the specified instance.

[Visual Basic]
returnValue = TimeSpan.op_UnaryNegation(t)
[C#]
public static TimeSpan operator -(
 TimeSpan t
);
[C++]
public: static TimeSpan op_UnaryNegation(
 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. You can use the Negate method instead of the TimeSpan unary negation operator.

[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

A TimeSpan with the same numeric value as this instance, but the opposite sign.

Exceptions

Exception Type Condition
OverflowException The negated value of this instance cannot be represented by a TimeSpan; that is, the value of this instance is MinValue.

Example

[Visual Basic, C#, C++] The following code example applies the Unary Negation 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, .NET Compact Framework, Common Language Infrastructure (CLI) Standard

See Also

TimeSpan Structure | TimeSpan Members | System Namespace

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.