TimeSpan Struct

Definizione

Rappresenta un intervallo di tempo.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
[System.Serializable]
public struct TimeSpan : IComparable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
type TimeSpan = struct
    interface IFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type TimeSpan = struct
    interface IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Ereditarietà
TimeSpan
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene creata TimeSpan un'istanza di un oggetto che rappresenta la differenza tra due date. Visualizza quindi le TimeSpan proprietà dell'oggetto.

// Define two dates.
DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);

// Calculate the interval between the two dates.
TimeSpan interval = date2 - date1;
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString());

// Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays);
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours);
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes);
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds);
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks);

// This example displays the following output:
//       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
//          Value of Days Component:                             229
//          Total Number of Days:                   229.229340277778
//          Value of Hours Component:                              5
//          Total Number of Hours:                  5501.50416666667
//          Value of Minutes Component:                           30
//          Total Number of Minutes:                       330090.25
//          Value of Seconds Component:                           15
//          Total Number of Seconds:                      19,805,415
//          Value of Milliseconds Component:                       0
//          Total Number of Milliseconds:             19,805,415,000
//          Ticks:                               198,054,150,000,000
' Define two dates.
Dim date1 As Date = #1/1/2010 8:00:15AM#
Dim date2 As Date = #8/18/2010 1:30:30PM#
' Calculate the interval between the two dates.
Dim interval As TimeSpan = date2 - date1
Console.WriteLine("{0} - {1} = {2}", date2, date1, interval.ToString())
' Display individual properties of the resulting TimeSpan object.
Console.WriteLine("   {0,-35} {1,20}", "Value of Days Component:", interval.Days)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Days:", interval.TotalDays)
Console.WriteLine("   {0,-35} {1,20}", "Value of Hours Component:", interval.Hours)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Hours:", interval.TotalHours)
Console.WriteLine("   {0,-35} {1,20}", "Value of Minutes Component:", interval.Minutes)
Console.WriteLine("   {0,-35} {1,20}", "Total Number of Minutes:", interval.TotalMinutes)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Seconds Component:", interval.Seconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Seconds:", interval.TotalSeconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Value of Milliseconds Component:", interval.Milliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Total Number of Milliseconds:", interval.TotalMilliseconds)
Console.WriteLine("   {0,-35} {1,20:N0}", "Ticks:", interval.Ticks)
' The example displays the following output:
'       8/18/2010 1:30:30 PM - 1/1/2010 8:00:15 AM = 229.05:30:15
'          Value of Days Component:                             229
'          Total Number of Days:                   229.229340277778
'          Value of Hours Component:                              5
'          Total Number of Hours:                  5501.50416666667
'          Value of Minutes Component:                           30
'          Total Number of Minutes:                       330090.25
'          Value of Seconds Component:                           15
'          Total Number of Seconds:                      19,805,415
'          Value of Milliseconds Component:                       0
'          Total Number of Milliseconds:             19,805,415,000
'          Ticks:                               198,054,150,000,000
# Define two dates.
$Date2 = Get-Date -Date '2010/8/18' -Hour 13 -Minute 30 -Second 30
$Date1 = Get-Date -Date '2010/1/1'  -Hour 8  -Minute 0  -Second 15

# Calculate the interval between the two dates.
$Interval = $Date2 - $Date1
"{0} - {1} = {2}" -f $Date2, $Date1, ($Interval.ToString())

#  Display individual properties of the resulting TimeSpan object.
"   {0,-35} {1,20}"    -f "Value of Days Component:", $Interval.Days
"   {0,-35} {1,20}"    -f "Total Number of Days:", $Interval.TotalDays
"   {0,-35} {1,20}"    -f "Value of Hours Component:", $Interval.Hours
"   {0,-35} {1,20}"    -f "Total Number of Hours:", $Interval.TotalHours
"   {0,-35} {1,20}"    -f "Value of Minutes Component:", $Interval.Minutes
"   {0,-35} {1,20}"    -f "Total Number of Minutes:", $Interval.TotalMinutes
"   {0,-35} {1,20:N0}" -f "Value of Seconds Component:", $Interval.Seconds
"   {0,-35} {1,20:N0}" -f "Total Number of Seconds:", $Interval.TotalSeconds
"   {0,-35} {1,20:N0}" -f "Value of Milliseconds Component:", $Interval.Milliseconds
"   {0,-35} {1,20:N0}" -f "Total Number of Milliseconds:", $Interval.TotalMilliseconds
"   {0,-35} {1,20:N0}" -f "Ticks:", $Interval.Ticks

<# This sample produces the following output:

18/08/2010 13:30:30 - 01/01/2010 08:00:15 = 229.05:30:15
   Value of Days Component:                             229
   Total Number of Days:                   229.229340277778
   Value of Hours Component:                              5
   Total Number of Hours:                  5501.50416666667
   Value of Minutes Component:                           30
   Total Number of Minutes:                       330090.25
   Value of Seconds Component:                           15
   Total Number of Seconds:                      19,805,415
   Value of Milliseconds Component:                       0
   Total Number of Milliseconds:             19,805,415,000
   Ticks:                               198,054,150,000,000
#>

Commenti

Un oggetto rappresenta un intervallo di tempo (durata del tempo o tempo trascorso) misurato come numero positivo o negativo di giorni, ore, minuti, secondi e frazioni di TimeSpan secondo. La TimeSpan struttura può essere usata anche per rappresentare l'ora del giorno, ma solo se l'ora non è correlata a una data specifica. In caso contrario, DateTime deve essere usata la struttura o DateTimeOffset . Per altre informazioni sull'uso della struttura per riflettere l'ora del giorno, vedere Scelta tra TimeSpan DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.

Nota

Un valore rappresenta un intervallo di tempo e può essere espresso come numero specifico di TimeSpan giorni, ore, minuti, secondi e millisecondi. Poiché rappresenta un intervallo generale senza riferimento a un determinato punto iniziale o finale, non può essere espresso in termini di anni e mesi, entrambi con un numero variabile di giorni. Si differenzia da un valore, che rappresenta una data e un'ora senza riferimento a un fuso orario specifico, o un valore che rappresenta DateTime DateTimeOffset un momento specifico dell'ora.

L'unità di tempo più grande utilizzata TimeSpan dalla struttura per misurare la durata è un giorno. Gli intervalli di tempo vengono misurati in giorni per coerenza, perché il numero di giorni in unità di tempo più grandi, ad esempio mesi e anni, varia.

Il valore di un TimeSpan oggetto è il numero di tick uguali all'intervallo di tempo rappresentato. Un tick è uguale a 100 nanosecondi o a un deci millionesimo di secondo. Il valore di un TimeSpan oggetto può essere compreso tra e TimeSpan.MinValue TimeSpan.MaxValue .

Creazione di un'istanza di un valore TimeSpan

È possibile creare TimeSpan un'istanza di un valore in diversi modi:

  • Chiamando il relativo costruttore implicito senza parametri. Verrà creato un oggetto il cui valore è TimeSpan.Zero , come illustrato nell'esempio seguente.

    TimeSpan interval = new TimeSpan();
    Console.WriteLine(interval.Equals(TimeSpan.Zero));    // Displays "True".
    
    Dim interval As New TimeSpan()
    Console.WriteLine(interval.Equals(TimeSpan.Zero))     ' Displays "True".
    
  • Chiamando uno dei costruttori espliciti. Nell'esempio seguente viene TimeSpan inizializzato un valore su un numero specificato di ore, minuti e secondi.

    TimeSpan interval = new TimeSpan(2, 14, 18);
    Console.WriteLine(interval.ToString());              
    
    // Displays "02:14:18".
    
    Dim interval As New TimeSpan(2, 14, 18)
    Console.WriteLine(interval.ToString())                ' Displays "02:14:18".
    
  • Chiamando un metodo o eseguendo un'operazione che restituisce un TimeSpan valore. Ad esempio, è possibile creare un'istanza di un valore che rappresenta l'intervallo tra due valori di data TimeSpan e ora, come illustrato nell'esempio seguente.

    DateTime departure = new DateTime(2010, 6, 12, 18, 32, 0);
    DateTime arrival = new DateTime(2010, 6, 13, 22, 47, 0);
    TimeSpan travelTime = arrival - departure;  
    Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime);      
    
    // The example displays the following output:
    //       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    
    Dim departure As DateTime = #06/12/2010 6:32PM#
    Dim arrival As DateTime = #06/13/2010 10:47PM#
    Dim travelTime As TimeSpan = arrival - departure  
    Console.WriteLine("{0} - {1} = {2}", arrival, departure, travelTime)      
    ' The example displays the following output:
    '       6/13/2010 10:47:00 PM - 6/12/2010 6:32:00 PM = 1.04:15:00
    

    È anche possibile inizializzare un TimeSpan oggetto su un valore di ora zero in questo modo, come illustrato nell'esempio seguente.

       Random rnd = new Random();
    
       TimeSpan timeSpent = TimeSpan.Zero;
    
       timeSpent += GetTimeBeforeLunch();
       timeSpent += GetTimeAfterLunch();
    
       Console.WriteLine("Total time: {0}", timeSpent);
    
       TimeSpan GetTimeBeforeLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
       
       TimeSpan GetTimeAfterLunch()
       {
          return new TimeSpan(rnd.Next(3, 6), 0, 0);
       }
    
       // The example displays output like the following:
       //        Total time: 08:00:00
    
    Module Example
       Dim rnd As New Random()
       
       Public Sub Main()
          Dim timeSpent As TimeSpan = TimeSpan.Zero
    
          timeSpent += GetTimeBeforeLunch()
          timeSpent += GetTimeAfterLunch()
    
          Console.WriteLine("Total time: {0}", timeSpent)
       End Sub
       
       Private Function GetTimeBeforeLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
       
       Private Function GetTimeAfterLunch() As TimeSpan
          Return New TimeSpan(rnd.Next(3, 6), 0, 0)
       End Function
    End Module
    ' The example displays output like the following:
    '       Total time: 08:00:00
    

    TimeSpan I valori vengono restituiti dagli operatori aritmetici e dai metodi delle DateTime DateTimeOffset strutture , e TimeSpan .

  • Analizzando la rappresentazione di stringa di un TimeSpan valore. È possibile usare i Parse metodi e per convertire stringhe TryParse contenenti intervalli di tempo in TimeSpan valori . Nell'esempio seguente viene Parse utilizzato il metodo per convertire una matrice di stringhe in valori TimeSpan .

    string[] values = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"};
    foreach (string value in values)
    {
       try {
          TimeSpan ts = TimeSpan.Parse(value);
          Console.WriteLine("'{0}' --> {1}", value, ts);
       }
       catch (FormatException) {
          Console.WriteLine("Unable to parse '{0}'", value);
       }
       catch (OverflowException) {
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value);
       }   
    }
    
    // The example displays the following output:
    //       '12' --> 12.00:00:00
    //       Unable to parse '31.'
    //       '5.8:32:16' --> 5.08:32:16
    //       '12:12:15.95' --> 12:12:15.9500000
    //       Unable to parse '.12'
    
    Dim values() As String = { "12", "31.", "5.8:32:16", "12:12:15.95", ".12"}
    For Each value As String In values
       Try
          Dim ts As TimeSpan = TimeSpan.Parse(value)
          Console.WriteLine("'{0}' --> {1}", value, ts)
       Catch e As FormatException
          Console.WriteLine("Unable to parse '{0}'", value)
       Catch e As OverflowException
          Console.WriteLine("'{0}' is outside the range of a TimeSpan.", value)
       End Try   
    Next
    ' The example displays the following output:
    '       '12' --> 12.00:00:00
    '       Unable to parse '31.'
    '       '5.8:32:16' --> 5.08:32:16
    '       '12:12:15.95' --> 12:12:15.9500000
    '       Unable to parse '.12'
    

    È anche possibile definire il formato preciso della stringa di input da analizzare e convertire in un TimeSpan valore chiamando il metodo o ParseExact TryParseExact .

Esecuzione di operazioni sui valori TimeSpan

È possibile aggiungere e sottrarre durate tempo usando gli operatori Addition e o chiamando i metodi e Subtraction Add Subtract . È anche possibile confrontare due durate chiamando i Compare metodi CompareTo , e Equals . La TimeSpan struttura include anche i metodi e , che Duration Negate convertono gli intervalli di tempo in valori positivi e negativi,

L'intervallo TimeSpan di valori è MinValue MaxValue .

Formattazione di un valore TimeSpan

Un TimeSpan valore può essere rappresentato come [ ] - d.hh:mm:ss. ff, dove il segno meno facoltativo indica un intervallo di tempo negativo, il componente d è giorni, hh è ore misurate su un orologio a 24 ore, mm è minuti, ss è secondi e ff è frazioni di secondo. Un intervallo di tempo è costituito da un numero positivo o negativo di giorni senza un'ora del giorno o da un numero di giorni con un'ora del giorno o solo da un'ora del giorno.

A partire dal .NET Framework 4, la struttura supporta la formattazione sensibile alle impostazioni cultura tramite gli overload del relativo metodo , che converte un valore nella relativa rappresentazione TimeSpan ToString di TimeSpan stringa. Il metodo predefinito restituisce un intervallo di tempo usando un formato invariante identico al relativo valore restituito nelle versioni precedenti del TimeSpan.ToString() .NET Framework. TimeSpan.ToString(String)L'overload consente di specificare una stringa di formato che definisce la rappresentazione di stringa dell'intervallo di tempo. L'overload consente di specificare una stringa di formato e le impostazioni cultura le cui convenzioni di formattazione vengono usate per creare la rappresentazione di stringa TimeSpan.ToString(String, IFormatProvider) dell'intervallo di tempo. TimeSpan supporta stringhe di formato standard e personalizzate. Per altre informazioni, vedere Stringhe di formato TimeSpan standard e Stringhe di formato TimeSpan personalizzate. Tuttavia, solo le stringhe di formato standard sono con distinzione delle impostazioni cultura.

Ripristino della formattazione TimeSpan legacy

In alcuni casi, il codice che formatta correttamente i valori in .NET Framework 3.5 e versioni precedenti non riesce TimeSpan in .NET Framework 4. Ciò è più comune nel codice che chiama un metodo<TimeSpan_LegacyFormatMode> per formattare un valore con una stringa di TimeSpan formato. L'esempio seguente formatta correttamente un valore in .NET Framework 3.5 e versioni precedenti, ma genera un'eccezione in .NET Framework TimeSpan 4 e versioni successive. Si noti che tenta di formattare un valore usando un identificatore di formato non supportato, che viene ignorato in .NET Framework TimeSpan 3.5 e versioni precedenti.

ShowFormattingCode();
// Output from .NET Framework 3.5 and earlier versions:
//       12:30:45
// Output from .NET Framework 4:
//       Invalid Format    

Console.WriteLine("---");

ShowParsingCode();
// Output:
//       000000006 --> 6.00:00:00

void ShowFormattingCode()
{
   TimeSpan interval = new TimeSpan(12, 30, 45);
   string output;
   try {
      output = String.Format("{0:r}", interval);
   }
   catch (FormatException) {
      output = "Invalid Format";
   }
   Console.WriteLine(output);
}

void ShowParsingCode()
{
   string value = "000000006";
   try {
      TimeSpan interval = TimeSpan.Parse(value);
      Console.WriteLine("{0} --> {1}", value, interval);
   }
   catch (FormatException) {
      Console.WriteLine("{0}: Bad Format", value);
   }   
   catch (OverflowException) {
      Console.WriteLine("{0}: Overflow", value);
   }
}
Dim interval As New TimeSpan(12, 30, 45)
Dim output As String
Try
   output = String.Format("{0:r}", interval)
Catch e As FormatException
   output = "Invalid Format"
End Try
Console.WriteLine(output)
' Output from .NET Framework 3.5 and earlier versions:
'       12:30:45
' Output from .NET Framework 4:
'       Invalid Format

Se non è possibile modificare il codice, è possibile ripristinare la formattazione legacy dei TimeSpan valori in uno dei modi seguenti:

  • Creando un file di configurazione che contiene l'<TimeSpan_LegacyFormatMode> elemento. L'impostazione dell'attributo enabled di questo elemento su ripristina la true TimeSpan formattazione legacy per ogni applicazione.

  • Impostando l'opzione di compatibilità "NetFx40_TimeSpanLegacyFormatMode" quando si crea un dominio applicazione. In questo modo TimeSpan la formattazione legacy viene abilitata in base al dominio dell'applicazione. Nell'esempio seguente viene creato un dominio applicazione che usa la formattazione TimeSpan legacy.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          AppDomainSetup appSetup = new AppDomainSetup();
          appSetup.SetCompatibilitySwitches( new string[] { "NetFx40_TimeSpanLegacyFormatMode" } );
          AppDomain legacyDomain = AppDomain.CreateDomain("legacyDomain", 
                                                          null, appSetup);
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe");
       }
    }
    
    Module Example
       Public Sub Main()
          Dim appSetup As New AppDomainSetup()
          appSetup.SetCompatibilitySwitches( { "NetFx40_TimeSpanLegacyFormatMode" } )
          Dim legacyDomain As AppDomain = AppDomain.CreateDomain("legacyDomain", 
                                                                 Nothing, appSetup)
          legacyDomain.ExecuteAssembly("ShowTimeSpan.exe")
       End Sub
    End Module
    

    Quando il codice seguente viene eseguito nel nuovo dominio applicazione, viene ripristinato il comportamento di TimeSpan formattazione legacy.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan interval = DateTime.Now - DateTime.Now.Date;
          string msg = String.Format("Elapsed Time Today: {0:d} hours.",
                                     interval);
          Console.WriteLine(msg);
       }
    }
    // The example displays the following output:
    //       Elapsed Time Today: 01:40:52.2524662 hours.
    
    Module Example
       Public Sub Main()
          Dim interval As TimeSpan = Date.Now - Date.Now.Date
          Dim msg As String = String.Format("Elapsed Time Today: {0:d} hours.",
                                             interval)
          Console.WriteLine(msg)
       End Sub
    End Module
    ' The example displays output like the following:
    '       Elapsed Time Today: 01:40:52.2524662 hours.
    

Costruttori

TimeSpan(Int32, Int32, Int32)

Inizializza una nuova istanza della struttura TimeSpan su un numero di ore, minuti e secondi specificato.

TimeSpan(Int32, Int32, Int32, Int32)

Inizializza una nuova istanza della struttura TimeSpan su un numero di giorni, ore, minuti e secondi specificato.

TimeSpan(Int32, Int32, Int32, Int32, Int32)

Inizializza una nuova istanza della struttura TimeSpan su un numero di giorni, ore, minuti, secondi e millisecondi specificato.

TimeSpan(Int64)

Inizializza una nuova istanza della struttura TimeSpan su un numero di tick specificato.

Campi

MaxValue

Rappresenta il valore massimo di TimeSpan. Questo campo è di sola lettura.

MinValue

Rappresenta il valore minimo di TimeSpan. Questo campo è di sola lettura.

TicksPerDay

Rappresenta il numero di tick in 1 giorno. Questo campo è costante.

TicksPerHour

Rappresenta il numero di tick in 1 ora. Questo campo è costante.

TicksPerMillisecond

Rappresenta il numero di tick in 1 millisecondo. Questo campo è costante.

TicksPerMinute

Rappresenta il numero di tick in 1 minuto. Questo campo è costante.

TicksPerSecond

Rappresenta il numero di tick in 1 secondo.

Zero

Rappresenta il valore zero di TimeSpan. Questo campo è di sola lettura.

Proprietà

Days

Ottiene il componente relativo ai giorni dell'intervallo di tempo rappresentato dalla struttura TimeSpan corrente.

Hours

Ottiene il componente relativo alle ore dell'intervallo di tempo rappresentato dalla struttura TimeSpan corrente.

Milliseconds

Ottiene il componente relativo ai millisecondi dell'intervallo di tempo rappresentato dalla struttura TimeSpan corrente.

Minutes

Ottiene il componente relativo ai minuti dell'intervallo di tempo rappresentato dalla struttura TimeSpan corrente.

Seconds

Ottiene il componente relativo ai secondi dell'intervallo di tempo rappresentato dalla struttura TimeSpan corrente.

Ticks

Ottiene il numero di tick che rappresentano il valore della struttura TimeSpan corrente.

TotalDays

Ottiene il valore della struttura TimeSpan corrente espresso in giorni interi e frazionari.

TotalHours

Ottiene il valore della struttura TimeSpan corrente espresso in ore intere e frazionarie.

TotalMilliseconds

Ottiene il valore della struttura TimeSpan corrente espresso in millisecondi interi e frazionari.

TotalMinutes

Ottiene il valore della struttura TimeSpan corrente espresso in minuti interi e frazionari.

TotalSeconds

Ottiene il valore della struttura TimeSpan corrente espresso in secondi interi e frazionari.

Metodi

Add(TimeSpan)

Restituisce un nuovo oggetto TimeSpan il cui valore è la somma dell'oggetto TimeSpan specificato e di questa istanza.

Compare(TimeSpan, TimeSpan)

Confronta due valori TimeSpan e restituisce un intero che indica se il primo valore è più breve, uguale o più lungo del secondo valore.

CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se questa istanza è più breve, uguale o più lunga dell'oggetto specificato.

CompareTo(TimeSpan)

Confronta questa istanza con un oggetto TimeSpan specificato e restituisce un intero che indica se questa istanza è più breve, uguale o più lunga dell'oggetto TimeSpan.

Divide(Double)

Restituisce un nuovo oggetto TimeSpan il cui valore è il risultato della divisione di questa istanza e del divisor specificato.

Divide(TimeSpan)

Restituisce un nuovo valore Double che è il risultato della divisione di questa istanza per il valore di ts specificato.

Duration()

Restituisce un nuovo oggetto TimeSpan il cui valore è il valore assoluto dell'oggetto TimeSpan corrente.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

Equals(TimeSpan)

Restituisce un valore che indica se questa istanza è uguale a un oggetto TimeSpan specificato.

Equals(TimeSpan, TimeSpan)

Restituisce un valore che indica se due istanze specificate di TimeSpan sono uguali.

FromDays(Double)

Restituisce un oggetto TimeSpan che rappresenta un numero di giorni specificato, in cui la specifica è approssimata al millisecondo più vicino.

FromHours(Double)

Restituisce un oggetto TimeSpan che rappresenta un numero di ore specificato, in cui la specifica è approssimata al millisecondo più vicino.

FromMilliseconds(Double)

Restituisce un oggetto TimeSpan che rappresenta un numero di millisecondi specificato.

FromMinutes(Double)

Restituisce un oggetto TimeSpan che rappresenta un numero di minuti specificato, in cui la specifica è approssimata al millisecondo più vicino.

FromSeconds(Double)

Restituisce un oggetto TimeSpan che rappresenta un numero di secondi specificato, in cui la specifica è approssimata al millisecondo più vicino.

FromTicks(Int64)

Restituisce un oggetto TimeSpan che rappresenta un'ora specificata, in cui la specifica è espressa in unità di tick.

GetHashCode()

Restituisce un codice hash per questa istanza.

Multiply(Double)

Restituisce un nuovo oggetto TimeSpan il cui valore è il risultato della moltiplicazione di questa istanza per il valore factor specificato.

Negate()

Restituisce un nuovo oggetto TimeSpan il cui valore è il valore negato di questa istanza.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Converte una rappresentazione intervallo di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate.

Parse(String)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan.

Parse(String, IFormatProvider)

Converte una rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate.

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles)

Converte l'intervallo di caratteri di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando i formati, gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

ParseExact(String, String, IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

ParseExact(String, String[], IFormatProvider)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando la matrice di stringhe di formato e le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

ParseExact(String, String[], IFormatProvider, TimeSpanStyles)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando i formati, gli stili e le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

Subtract(TimeSpan)

Restituisce un nuovo oggetto TimeSpan il cui valore è la differenza tra l'oggetto TimeSpan specificato e questa istanza.

ToString()

Converte il valore dell'oggetto TimeSpan corrente nella rappresentazione di stringa equivalente.

ToString(String)

Converte il valore dell'oggetto TimeSpan corrente nella rappresentazione di stringa equivalente usando il formato specificato.

ToString(String, IFormatProvider)

Converte il valore dell'oggetto TimeSpan corrente nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Prova a formattare il valore dell'istanza del numero timespan corrente nell'intervallo di caratteri specificato.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Converte la rappresentazione intervallo di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni di formattazione specifiche delle impostazioni cultura indicate e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Converte la rappresentazione intervallo di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni di formattazione specifiche delle impostazioni cultura indicate e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParse(String, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan e restituisce un valore che indica se la conversione è stata eseguita correttamente.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Converte la rappresentazione in forma di intervallo specificata di un intervallo di tempo nell'equivalente TimeSpan usando il formato e le informazioni sul formato specifiche delle impostazioni cultura specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione intervallo specificata di un intervallo di tempo nell'equivalente TimeSpan usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati e restituisce un valore che indica se la conversione è stata eseguita correttamente. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpan)

Converte la rappresentazione in forma di intervallo specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati e le informazioni sul formato specifiche delle impostazioni cultura specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione in forma di intervallo specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Converte la rappresentazione di stringa di un intervallo di tempo nell'equivalente TimeSpan usando le informazioni sul formato specifiche delle impostazioni cultura indicate. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

TryParseExact(String, String, IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione stringa di un intervallo di tempo nell'equivalente TimeSpan usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente al formato specificato.

TryParseExact(String, String[], IFormatProvider, TimeSpan)

Converte la rappresentazione stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando i formati e le informazioni sul formato specifiche delle impostazioni cultura specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

TryParseExact(String, String[], IFormatProvider, TimeSpanStyles, TimeSpan)

Converte la rappresentazione stringa specificata di un intervallo di tempo nell'equivalente TimeSpan usando il formato, le informazioni sul formato specifiche delle impostazioni cultura e gli stili specificati. Il formato della rappresentazione di stringa deve corrispondere esattamente a uno dei formati specificati.

Operatori

Addition(TimeSpan, TimeSpan)

Aggiunge due istanze di TimeSpan specificate.

Division(TimeSpan, Double)

Restituisce un nuovo oggetto TimeSpan il cui valore è il risultato della divisione dell'istanza di timeSpan per il valore divisor specificato.

Division(TimeSpan, TimeSpan)

Restituisce un nuovo valore Double che è il risultato della divisione dell'istanza di t1 per il valore t2 specificato.

Equality(TimeSpan, TimeSpan)

Indica se due istanze di TimeSpan sono uguali.

GreaterThan(TimeSpan, TimeSpan)

Indica se un oggetto TimeSpan specificato è maggiore di un altro oggetto TimeSpan specificato.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Indica se un oggetto TimeSpan specificato è maggiore o uguale a un altro oggetto TimeSpan specificato.

Inequality(TimeSpan, TimeSpan)

Indica se due istanze di TimeSpan non sono uguali.

LessThan(TimeSpan, TimeSpan)

Indica se un oggetto TimeSpan specificato è minore di un altro oggetto TimeSpan specificato.

LessThanOrEqual(TimeSpan, TimeSpan)

Indica se un oggetto TimeSpan specificato è minore o uguale a un altro oggetto TimeSpan specificato.

Multiply(Double, TimeSpan)

Restituisce un nuovo oggetto TimeSpan il cui valore è il risultato della moltiplicazione del factor specificato per l'istanza di timeSpan specificata.

Multiply(TimeSpan, Double)

Restituisce un nuovo oggetto TimeSpan il cui valore è il risultato della moltiplicazione dell'istanza di timeSpan specificata per il factorspecificato.

Subtraction(TimeSpan, TimeSpan)

Sottrae un oggetto TimeSpan specificato da un altro oggetto TimeSpan specificato.

UnaryNegation(TimeSpan)

Restituisce un oggetto TimeSpan il cui valore è il valore negato dell'istanza specificata.

UnaryPlus(TimeSpan)

Restituisce l'istanza specificata di TimeSpan.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta questa istanza con un oggetto specificato e restituisce un intero che indica se questa istanza è più breve, uguale o più lunga dell'oggetto specificato.

Si applica a

Vedi anche