Επεξεργασία

Κοινή χρήση μέσω


TimeSpan.UnaryNegation(TimeSpan) Operator

Definition

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

public:
 static TimeSpan operator -(TimeSpan t);
public static TimeSpan operator - (TimeSpan t);
static member ( ~- ) : TimeSpan -> TimeSpan
Public Shared Operator - (t As TimeSpan) As TimeSpan

Parameters

t
TimeSpan

The time interval to be negated.

Returns

An object that has the same numeric value as this instance, but the opposite sign.

Exceptions

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

Examples

The following example applies the UnaryNegation operator to several TimeSpan objects.

// Example of the TimeSpan::Duration( ) and TimeSpan::Negate( ) methods,
// and the TimeSpan Unary Negation and Unary Plus operators.
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( gcnew String( protoFmt ), interval, interval.Duration(), interval.Negate() );
}

int 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( gcnew String( protoFmt ), "TimeSpan", "Duration( )", "Negate( )" );
   Console::WriteLine( gcnew String( protoFmt ), "--------", "-----------", "---------" );
   
   // 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
*/
// 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
*/
// Example of the TimeSpan.Duration( ) and TimeSpan.Negate( ) methods,
// and the TimeSpan Unary Negation and Unary Plus operators.
open System

let showDurationNegate (interval: TimeSpan) =
    // Display the TimeSpan value and the results of the 
    // Duration and Negate methods.
    printfn $"{interval,22}{interval.Duration(),22}{interval.Negate(),22}"

printfn "This example of TimeSpan.Duration( ), TimeSpan.Negate( ), \nand the TimeSpan Unary Negation and Unary Plus operators \ngenerates the following output.\n" 
printfn "%22s%22s%22s" "TimeSpan" "Duration( )" "Negate( )"
printfn "%22s%22s%22s" "--------" "-----------" "---------"

// 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
*)
' Example of the TimeSpan.Duration( ) and TimeSpan.Negate( ) methods,
' and the TimeSpan Unary Negation and Unary Plus operators.
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

Remarks

The equivalent method for this operator is TimeSpan.Negate()

Applies to