TimeSpan Struct

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Rappresenta un intervallo di tempo.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>

public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>

type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>

Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan)

Ereditarietà

Object

ValueType

TimeSpan

Implementazioni

IComparable IComparable<TimeSpan> IEquatable<TimeSpan> IFormattable ISpanFormattable IParsable<TimeSpan> IParsable<TSelf> ISpanParsable<TimeSpan>

Esempio

Nell'esempio seguente viene creata un'istanza di un TimeSpan 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.
let date1 = DateTime(2010, 1, 1, 8, 0, 15)
let date2 = DateTime(2010, 8, 18, 13, 30, 30)

// Calculate the interval between the two dates.
let interval = date2 - date1
printfn $"{date2} - {date1} = {interval}"

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

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

Nota

Un TimeSpan valore rappresenta un intervallo di tempo e può essere espresso come un determinato numero di 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. È diverso da un DateTime valore, che rappresenta una data e un'ora senza riferimento a un determinato fuso orario o a un DateTimeOffset valore, che rappresenta un momento specifico di ora.

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

Il valore di un TimeSpan oggetto è il numero di tick uguali all'intervallo di tempo rappresentato. Un segno di spunta è uguale a 100 nanosecondi o un milione di secondi. Il valore di un TimeSpan oggetto può variare da TimeSpan.MinValue a TimeSpan.MaxValue.

Creazione di un'istanza di un valore TimeSpan

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

• Chiamando il costruttore implicito senza parametri. In questo modo viene 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".
  

  let interval = TimeSpan()
  printfn $"{interval.Equals TimeSpan.Zero}"    // Displays "True".
  

  Dim interval As New TimeSpan()
  Console.WriteLine(interval.Equals(TimeSpan.Zero))     ' Displays "True".
  

• Chiamando uno dei suoi costruttori espliciti. Nell'esempio seguente viene inizializzato un TimeSpan valore in un numero specificato di ore, minuti e secondi.

  TimeSpan interval = new TimeSpan(2, 14, 18);
  Console.WriteLine(interval.ToString());              
  
  // Displays "02:14:18".
  

  let interval = TimeSpan(2, 14, 18)
  printfn $"{interval}"              
  
  // 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 TimeSpan valore che rappresenta l'intervallo tra due valori di data 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
  

  let departure = DateTime(2010, 6, 12, 18, 32, 0)
  let arrival = DateTime(2010, 6, 13, 22, 47, 0)
  let travelTime = arrival - departure  
  printfn $"{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 a un valore di tempo 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
  

  open System
  
  let rnd = Random()
  
  let getTimeBeforeLunch () =
      TimeSpan(rnd.Next(3, 6), 0, 0)
  
  let getTimeAfterLunch() =
      TimeSpan(rnd.Next(3, 6), 0, 0)
  
  do
      let timeSpent = TimeSpan.Zero
  
      let timeSpent = timeSpent + getTimeBeforeLunch ()
      let timeSpent = timeSpent + getTimeAfterLunch ()
  
      printfn $"Total time: {timeSpent}"
  
  
  // 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 da operatori e metodi aritmetici delle DateTimestrutture , DateTimeOffsete TimeSpan .

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

  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'
  

  let values = [| "12"; "31."; "5.8:32:16"; "12:12:15.95"; ".12" |]
  for value in values do
      try
          let ts = TimeSpan.Parse value
          printfn $"'{value}' --> {ts}"
      with 
      | :? FormatException ->
          printfn $"Unable to parse '{value}'"
      | :? OverflowException ->
          printfn $"'{value}' is outside the range of a TimeSpan."
  
  // 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'
  

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

Esecuzione di operazioni sui valori TimeSpan

È possibile aggiungere e sottraere durate di tempo usando gli Addition operatori e oppure chiamando i Add metodi e SubtractionSubtract. È anche possibile confrontare due durate di tempo chiamando i Comparemetodi , CompareToe Equals . La TimeSpan struttura include anche i Duration metodi e Negate , che converte gli intervalli di tempo in valori positivi e negativi,

L'intervallo di TimeSpan 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 di 24 ore, mm è minuti, ss è secondi e ff è frazione di un secondo. Vale a dire, un intervallo di tempo è costituito da un numero positivo o negativo di giorni senza un'ora del giorno, o un numero di giorni con un'ora del giorno o solo un'ora del giorno.

A partire da .NET Framework 4, la TimeSpan struttura supporta la formattazione sensibile alle impostazioni cultura tramite gli overload del ToString metodo, che converte un TimeSpan valore nella relativa rappresentazione di stringa. Il metodo predefinito TimeSpan.ToString() restituisce un intervallo di tempo usando un formato invariante identico al relativo valore restituito nelle versioni precedenti di .NET Framework. L'overload TimeSpan.ToString(String) consente di specificare una stringa di formato che definisce la rappresentazione stringa dell'intervallo di tempo. L'overload TimeSpan.ToString(String, IFormatProvider) consente di specificare una stringa di formato e le impostazioni cultura le cui convenzioni di formattazione vengono usate per creare la rappresentazione stringa 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 TimeSpanpersonalizzate. Tuttavia, solo le stringhe di formato standard sono sensibili alle impostazioni cultura.

Ripristino della formattazione timeSpan legacy

In alcuni casi, il codice che formatta TimeSpan correttamente i valori in .NET Framework 3.5 e versioni precedenti ha esito negativo in .NET Framework 4. Questo è più comune nel codice che chiama un <metodo di elemento TimeSpan_LegacyFormatMode> per formattare un TimeSpan valore con una stringa di formato. L'esempio seguente formatta correttamente un valore in .NET Framework 3.5 e versioni precedenti, ma genera un'eccezione TimeSpan in .NET Framework 4 e versioni successive. Si noti che tenta di formattare un valore usando un TimeSpan identificatore di formato non supportato, ignorato in .NET Framework 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);
   }
}

let showFormattingCode () =
    let interval = TimeSpan(12, 30, 45)
    try
        $"{interval:r}"
    with :? FormatException ->
        "Invalid Format"
    |> printfn "%s"

let showParsingCode () =
    let value = "000000006"
    try
        let interval = TimeSpan.Parse value
        printfn $"{value} --> {interval}"
    with
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"

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

printfn "---"

showParsingCode ()
// Output:
//       000000006 --> 6.00:00:00

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 contenente l'elemento< TimeSpan_LegacyFormatMode>. Impostando l'attributo di enabled questo elemento per true ripristinare la formattazione legacy TimeSpan in base all'applicazione.

• Impostando l'opzione di compatibilità "NetFx40_TimeSpanLegacyFormatMode" quando si crea un dominio applicazione. Ciò consente la formattazione legacy TimeSpan in base a un dominio per ogni applicazione. Nell'esempio seguente viene creato un dominio applicazione che usa la formattazione legacy TimeSpan .

  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");
     }
  }
  

  open System
  
  let appSetup = AppDomainSetup()
  appSetup.SetCompatibilitySwitches [| "NetFx40_TimeSpanLegacyFormatMode" |]
  let legacyDomain = AppDomain.CreateDomain("legacyDomain", null, appSetup)
  legacyDomain.ExecuteAssembly "ShowTimeSpan.exe" |> ignore
  

  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 dell'applicazione, viene ripristinato il comportamento di formattazione legacy TimeSpan .

  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.
  

  open System
  
  let interval = DateTime.Now - DateTime.Now.Date
  printfn $"Elapsed Time Today: {interval:d} hours."
  // 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(Int32, Int32, Int32, Int32, Int32, Int32)	Inizializza una nuova istanza della TimeSpan struttura in un numero specificato di giorni, ore, minuti, secondi, millisecondi e microsecondi specificati.
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.
NanosecondsPerTick	Rappresenta il numero di nanosecondi per tick. Questo campo è costante.
TicksPerDay	Rappresenta il numero di tick in 1 giorno. Questo campo è costante.
TicksPerHour	Rappresenta il numero di tick in 1 ora. Questo campo è costante.
TicksPerMicrosecond	Rappresenta il numero di tick in 1 microsecondo. 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.
Microseconds	Ottiene il componente dei microsecondi dell'intervallo di tempo rappresentato dalla struttura corrente TimeSpan .
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.
Nanoseconds	Ottiene il componente nanosecondi dell'intervallo di tempo rappresentato dalla struttura corrente TimeSpan .
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.
TotalMicroseconds	Ottiene il valore della struttura corrente TimeSpan espressa in microsecondi interi e frazionari.
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.
TotalNanoseconds	Ottiene il valore della struttura corrente TimeSpan espressa in nanosecondi 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 TimeSpan oggetto il cui valore è il risultato della divisione dell'istanza in base all'oggetto specificato divisor.
Divide(TimeSpan)	Restituisce un nuovo Double valore risultante dalla divisione di questa istanza per ts.
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.
FromMicroseconds(Double)	Restituisce un TimeSpan oggetto che rappresenta un numero specificato di microsecondi.
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 TimeSpan oggetto il cui valore è il risultato della divisione dell'oggetto specificato timeSpan dall'oggetto specificato divisor.
Division(TimeSpan, TimeSpan)	Restituisce un nuovo Double valore risultante dalla divisione t1 per t2.
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.

Vedi anche

• DateTime
• DateTimeOffset
• Calendar