TimeSpan Struct-datatyp

Definition

Representerar ett tidsintervall.

public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
public value class TimeSpan : IComparable
public value class TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable
public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>
[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 IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
    interface IUtf8SpanFormattable
type TimeSpan = struct
    interface ISpanFormattable
    interface IFormattable
type TimeSpan = struct
    interface IFormattable
    interface IParsable<TimeSpan>
    interface ISpanFormattable
    interface ISpanParsable<TimeSpan>
[<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), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan), IUtf8SpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), ISpanFormattable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan), IParsable(Of TimeSpan), ISpanFormattable, ISpanParsable(Of TimeSpan)
Public Structure TimeSpan
Implements IComparable
Public Structure TimeSpan
Implements IComparable, IComparable(Of TimeSpan), IEquatable(Of TimeSpan)
Arv
TimeSpan
Attribut
Implementeringar

Exempel

I följande exempel instansierar ett TimeSpan objekt som representerar skillnaden mellan två datum. Sedan visas objektets TimeSpan egenskaper.

// 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
#>

Kommentarer

Mer information om det här API:et finns i Kompletterande API-kommentarer för TimeSpan.

Konstruktorer

Name Description
TimeSpan(Int32, Int32, Int32, Int32, Int32, Int32)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal dagar, timmar, minuter, sekunder, millisekunder och mikrosekunder.

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

Initierar en ny instans av TimeSpan strukturen till ett angivet antal dagar, timmar, minuter, sekunder och millisekunder.

TimeSpan(Int32, Int32, Int32, Int32)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal dagar, timmar, minuter och sekunder.

TimeSpan(Int32, Int32, Int32)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal timmar, minuter och sekunder.

TimeSpan(Int64)

Initierar en ny instans av TimeSpan strukturen till det angivna antalet fästingar.

Fält

Name Description
HoursPerDay

Representerar antalet timmar på en dag. Det här fältet är konstant.

MaxValue

Representerar det maximala TimeSpan värdet. Detta fält är skrivskyddat.

MicrosecondsPerDay

Representerar antalet mikrosekunder på en dag. Det här fältet är konstant.

MicrosecondsPerHour

Representerar antalet mikrosekunder på 1 timme. Det här fältet är konstant.

MicrosecondsPerMillisecond

Representerar antalet mikrosekunder på 1 millisekunder. Det här fältet är konstant.

MicrosecondsPerMinute

Representerar antalet mikrosekunder på 1 minut. Det här fältet är konstant.

MicrosecondsPerSecond

Representerar antalet mikrosekunder på 1 sekund. Det här fältet är konstant.

MillisecondsPerDay

Representerar antalet millisekunder på 1 dag. Det här fältet är konstant.

MillisecondsPerHour

Representerar antalet millisekunder på 1 timme. Det här fältet är konstant.

MillisecondsPerMinute

Representerar antalet millisekunder på 1 minut. Det här fältet är konstant.

MillisecondsPerSecond

Representerar antalet millisekunder på 1 sekund. Det här fältet är konstant.

MinutesPerDay

Representerar antalet minuter på en dag. Det här fältet är konstant.

MinutesPerHour

Representerar antalet minuter på 1 timme. Det här fältet är konstant.

MinValue

Representerar det minsta TimeSpan värdet. Detta fält är skrivskyddat.

NanosecondsPerTick

Representerar antalet nanosekunder per tick. Det här fältet är konstant.

SecondsPerDay

Representerar antalet sekunder på en dag. Det här fältet är konstant.

SecondsPerHour

Representerar antalet sekunder på 1 timme. Det här fältet är konstant.

SecondsPerMinute

Representerar antalet sekunder på 1 minut. Det här fältet är konstant.

TicksPerDay

Representerar antalet tick på en dag. Det här fältet är konstant.

TicksPerHour

Representerar antalet fästingar på 1 timme. Det här fältet är konstant.

TicksPerMicrosecond

Representerar antalet fästingar på 1 mikrosekunder. Det här fältet är konstant.

TicksPerMillisecond

Representerar antalet fästingar på 1 millisekunder. Det här fältet är konstant.

TicksPerMinute

Representerar antalet fästingar på 1 minut. Det här fältet är konstant.

TicksPerSecond

Representerar antalet fästingar på 1 sekund.

Zero

Representerar nollvärdet TimeSpan . Detta fält är skrivskyddat.

Egenskaper

Name Description
Days

Hämtar dagskomponenten för tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Hours

Hämtar timkomponenten för tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Microseconds

Hämtar komponenten mikrosekunder i tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Milliseconds

Hämtar millisekunderskomponenten i tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Minutes

Hämtar minutkomponenten för tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Nanoseconds

Hämtar komponenten nanosekunder i tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Seconds

Hämtar sekundkomponenten för tidsintervallet som representeras av den aktuella TimeSpan strukturen.

Ticks

Hämtar antalet fästingar som representerar värdet för den aktuella TimeSpan strukturen.

TotalDays

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela dagar och bråkdagar.

TotalHours

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela timmar och bråktimmar.

TotalMicroseconds

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela och bråktalsmikrosekunder.

TotalMilliseconds

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela och bråk millisekunder.

TotalMinutes

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela och bråkminuter.

TotalNanoseconds

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela och bråkala nanosekunder.

TotalSeconds

Hämtar värdet för den aktuella TimeSpan strukturen uttryckt i hela och bråk sekunder.

Metoder

Name Description
Add(TimeSpan)

Returnerar ett nytt TimeSpan objekt vars värde är summan av det angivna TimeSpan objektet och den här instansen.

Compare(TimeSpan, TimeSpan)

Jämför två TimeSpan värden och returnerar ett heltal som anger om det första värdet är kortare än, lika med eller längre än det andra värdet.

CompareTo(Object)

Jämför den här instansen med ett angivet objekt och returnerar ett heltal som anger om den här instansen är kortare än, lika med eller längre än det angivna objektet.

CompareTo(TimeSpan)

Jämför den här instansen med ett angivet TimeSpan objekt och returnerar ett heltal som anger om den här instansen TimeSpan är kortare än, lika med eller längre än objektet.

Divide(Double)

Returnerar ett nytt TimeSpan objekt vars värde är resultatet av att dela instansen med den angivna divisor.

Divide(TimeSpan)

Returnerar ett nytt Double värde som är resultatet av att dela instansen med ts.

Duration()

Returnerar ett nytt TimeSpan objekt vars värde är det aktuella objektets TimeSpan absoluta värde.

Equals(Object)

Returnerar ett värde som anger om den här instansen är lika med ett angivet objekt.

Equals(TimeSpan, TimeSpan)

Returnerar ett värde som anger om två angivna instanser av TimeSpan är lika med.

Equals(TimeSpan)

Returnerar ett värde som anger om den här instansen är lika med ett angivet TimeSpan objekt.

FromDays(Double)

Returnerar ett TimeSpan som representerar ett angivet antal dagar, där specifikationen är korrekt till närmaste millisekunder.

FromDays(Int32, Int32, Int64, Int64, Int64, Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal dagar, timmar, minuter, sekunder, millisekunder och mikrosekunder.

FromDays(Int32)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal dagar.

FromHours(Double)

Returnerar ett TimeSpan som representerar ett angivet antal timmar, där specifikationen är korrekt till närmaste millisekunder.

FromHours(Int32, Int64, Int64, Int64, Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal timmar, minuter, sekunder, millisekunder och mikrosekunder.

FromHours(Int32)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal timmar.

FromMicroseconds(Double)

Returnerar ett TimeSpan som representerar ett angivet antal mikrosekunder.

FromMicroseconds(Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal mikrosekunder.

FromMilliseconds(Double)

Returnerar ett TimeSpan som representerar ett angivet antal millisekunder.

FromMilliseconds(Int64, Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal millisekunder och mikrosekunder.

FromMilliseconds(Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal millisekunder.

FromMinutes(Double)

Returnerar ett TimeSpan som representerar ett angivet antal minuter, där specifikationen är korrekt till närmaste millisekunder.

FromMinutes(Int64, Int64, Int64, Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal minuter, sekunder, millisekunder och mikrosekunder.

FromMinutes(Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal minuter.

FromSeconds(Double)

Returnerar en TimeSpan som representerar ett angivet antal sekunder, där specifikationen är korrekt till närmaste millisekunder.

FromSeconds(Int64, Int64, Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal sekunder, millisekunder och mikrosekunder.

FromSeconds(Int64)

Initierar en ny instans av TimeSpan strukturen till ett angivet antal sekunder.

FromTicks(Int64)

Returnerar en TimeSpan som representerar en angiven tid, där specifikationen finns i tickenheter.

GetHashCode()

Returnerar en hash-kod för den här instansen.

Multiply(Double)

Returnerar ett nytt TimeSpan objekt som är resultatet av multiplikation av den här instansen och den angivna factor.

Negate()

Returnerar ett nytt TimeSpan objekt vars värde är det negerade värdet för den här instansen.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Konverterar spanrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av den angivna kulturspecifika formatinformationen.

Parse(String, IFormatProvider)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av den angivna kulturspecifika formatinformationen.

Parse(String)

Konverterar strängrepresentationen av ett tidsintervall till motsvarande TimeSpan .

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

Konverterar teckenintervallet för ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet och den kulturspecifika formatinformationen. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av de angivna formaten, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

ParseExact(String, String, IFormatProvider)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet och kulturspecifik formatinformation. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av de angivna formaten, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

ParseExact(String, String[], IFormatProvider)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av den angivna matrisen med formatsträngar och kulturspecifik formatinformation. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

Subtract(TimeSpan)

Returnerar ett nytt TimeSpan objekt vars värde är skillnaden mellan det angivna TimeSpan objektet och den här instansen.

ToString()

Konverterar värdet för det aktuella TimeSpan objektet till motsvarande strängrepresentation.

ToString(String, IFormatProvider)

Konverterar värdet för det aktuella TimeSpan objektet till motsvarande strängrepresentation med hjälp av angivet format och kulturspecifik formateringsinformation.

ToString(String)

Konverterar värdet för det aktuella TimeSpan objektet till motsvarande strängrepresentation med det angivna formatet.

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

Försöker formatera värdet för den aktuella instansen som UTF-8 i det angivna byteintervallet.

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

Försöker formatera värdet för den aktuella tidsintervallnummerinstansen till det angivna intervallet med tecken.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

Konverterar intervallrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av den angivna kulturspecifika formateringsinformationen och returnerar ett värde som anger om konverteringen lyckades.

TryParse(ReadOnlySpan<Char>, TimeSpan)

Konverterar spanrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

TryParse(String, IFormatProvider, TimeSpan)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av den angivna kulturspecifika formateringsinformationen och returnerar ett värde som anger om konverteringen lyckades.

TryParse(String, TimeSpan)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

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

Konverterar den angivna intervallrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet och den kulturspecifika formatinformationen. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar den angivna intervallrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet, kulturspecifik formatinformation och formatmallar och returnerar ett värde som anger om konverteringen lyckades. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar den angivna spännviddsrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av de angivna formaten och den kulturspecifika formatinformationen. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

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

Konverterar den angivna intervallrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av de angivna formaten, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

TryParseExact(String, String, IFormatProvider, TimeSpan)

Konverterar strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av det angivna formatet och kulturspecifik formatinformation. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar strängrepresentationen av ett tidsintervall till motsvarande TimeSpan genom att använda det angivna formatet, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha det angivna formatet exakt.

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

Konverterar den angivna strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av angivna format och kulturspecifik formatinformation. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

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

Konverterar den angivna strängrepresentationen av ett tidsintervall till dess TimeSpan motsvarighet med hjälp av angivna format, kulturspecifik formatinformation och formatmallar. Formatet för strängrepresentationen måste matcha ett av de angivna formaten exakt.

Operatorer

Name Description
Addition(TimeSpan, TimeSpan)

Lägger till två angivna TimeSpan instanser.

Division(TimeSpan, Double)

Returnerar ett nytt TimeSpan objekt vars värde är resultatet av att dividera det som anges timeSpan av den angivna divisor.

Division(TimeSpan, TimeSpan)

Returnerar ett nytt Double värde som är resultatet av att dividera med t1t2 .

Equality(TimeSpan, TimeSpan)

Anger om två TimeSpan instanser är lika med.

GreaterThan(TimeSpan, TimeSpan)

Anger om en angiven TimeSpan är större än en annan angiven TimeSpan.

GreaterThanOrEqual(TimeSpan, TimeSpan)

Anger om en angiven TimeSpan är större än eller lika med en annan angiven TimeSpan.

Inequality(TimeSpan, TimeSpan)

Anger om två TimeSpan instanser inte är lika med.

LessThan(TimeSpan, TimeSpan)

Anger om en angiven TimeSpan är mindre än en annan angiven TimeSpan.

LessThanOrEqual(TimeSpan, TimeSpan)

Anger om en angiven TimeSpan är mindre än eller lika med en annan angiven TimeSpan.

Multiply(Double, TimeSpan)

Returnerar ett nytt TimeSpan objekt vars värde är resultatet av att multiplicera den angivna factor och angivna timeSpan instansen.

Multiply(TimeSpan, Double)

Returnerar ett nytt TimeSpan objekt vars värde är resultatet av att multiplicera den angivna timeSpan instansen och den angivna factor.

Subtraction(TimeSpan, TimeSpan)

Subtraherar en angiven TimeSpan från en annan angiven TimeSpan.

UnaryNegation(TimeSpan)

Returnerar ett TimeSpan vars värde är det negerade värdet för den angivna instansen.

UnaryPlus(TimeSpan)

Returnerar den angivna instansen av TimeSpan.

Explicita gränssnittsimplementeringar

Name Description
IComparable.CompareTo(Object)

Jämför den här instansen med ett angivet objekt och returnerar ett heltal som anger om den här instansen är kortare än, lika med eller längre än det angivna objektet.

Gäller för

Se även