TimeSpan 구조체

정의

시간 간격을 나타냅니다.

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, 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>, 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 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), 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)
상속
TimeSpan
특성
구현

예제

다음 예제에서는 두 날짜 간의 차이를 나타내는 개체를 인스턴스화 TimeSpan 합니다. 그런 다음 개체의 속성을 표시합니다 TimeSpan .

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

설명

개체는 TimeSpan 1초의 양수 또는 음수 일수, 시간, 분, 초 및 분수로 측정되는 시간 간격(시간 또는 경과 시간)을 나타냅니다. 구조체는 TimeSpan 특정 날짜와 관련이 없는 경우에만 하루 중 시간을 나타내는 데 사용할 수 있습니다. 그렇지 않으면 DateTime 또는 DateTimeOffset 구조체를 대신 사용해야 합니다. (구조를 사용하여 TimeSpan 하루 중 시간을 반영하는 방법에 대한 자세한 내용은 DateTime, DateTimeOffset, TimeSpan 및 TimeZoneInfo 중에서 선택을 참조하세요.)

참고

값은 TimeSpan 시간 간격을 나타내며 특정 일 수, 시간, 분, 초 및 밀리초로 표현할 수 있습니다. 특정 시작점이나 끝점에 대한 참조 없이 일반적인 간격을 나타내므로 연도 및 월로 표현할 수 없으며 둘 다 일 수가 가변적입니다. 특정 표준 시간대에 DateTime 대한 참조 없이 날짜와 시간을 나타내는 값 또는 DateTimeOffset 특정 시간을 나타내는 값과 다릅니다.

구조체가 TimeSpan 기간을 측정하는 데 사용하는 가장 큰 시간 단위는 일입니다. 시간 간격은 월 및 연도와 같이 더 큰 시간 단위의 일 수가 다르기 때문에 일관성을 위해 일 단위로 측정됩니다.

개체의 TimeSpan 값은 표시된 시간 간격과 동일한 틱 수입니다. 틱은 100나노초 또는 1초의 1,000만 분의 1과 같습니다. 개체의 값 범위는 TimeSpan 에서 로 TimeSpan.MinValue 지정할 TimeSpan.MaxValue수 있습니다.

TimeSpan 값 인스턴스화

다음과 같은 TimeSpan 여러 가지 방법으로 값을 인스턴스화할 수 있습니다.

  • 암시적 매개 변수 없는 생성자를 호출합니다. 다음 예제와 같이 값이 TimeSpan.Zero인 개체를 만듭니다.

    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".
    
  • 명시적 생성자 중 하나를 호출합니다. 다음 예제에서는 값을 지정된 시간, 분 및 초 수로 초기화 TimeSpan 합니다.

    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".
    
  • 메서드를 호출하거나 값을 반환하는 작업을 수행합니다 TimeSpan . 예를 들어 다음 예제와 같이 두 날짜 값과 시간 값 사이의 간격을 나타내는 값을 인스턴스화 TimeSpan 할 수 있습니다.

    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
    

    다음 예제와 같이 이러한 방식으로 개체를 TimeSpan 0 시간 값으로 초기화할 수도 있습니다.

       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값은 산술 연산자와 , DateTimeOffsetTimeSpan 구조체의 메서드에 DateTime의해 반환됩니다.

  • 값의 문자열 표현을 구문 분석합니다 TimeSpan . 및 TryParse 메서드를 Parse 사용하여 시간 간격이 포함된 문자열을 값으로 변환할 TimeSpan 수 있습니다. 다음 예제에서는 메서드를 Parse 사용하여 문자열 배열을 값으로 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'
    
    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'
    

    또한 또는 TryParseExact 메서드를 호출하여 구문 분석하고 값으로 변환할 입력 문자열의 정확한 형식을 ParseExact 정의할 TimeSpan 수 있습니다.

TimeSpan 값에 대한 작업 수행

및 연산자를 사용 Addition 하거나 및 Subtraction 메서드를 호출 AddSubtract 하여 기간을 추가하고 뺄 수 있습니다. , CompareToEquals 메서드를 호출Compare하여 두 시간 기간을 비교할 수도 있습니다. 구조체에는 TimeSpan 시간 간격을 Duration 양수 및 음수 값으로 변환하는 및 Negate 메서드도 포함됩니다.

값의 TimeSpan 범위는 입니다 MinValueMaxValue.

TimeSpan 값 서식 지정

TimeSpan 값을 [-]d로 나타낼 수 있습니다. hh:mm:ss. ff, 여기서 선택적 빼기 기호는 음수 시간 간격을 나타내고, d 구성 요소는 일, hh는 24시간 클록에서 측정된 시간, mm은 분, ss는 초, ff는 초의 분수입니다. 즉, 시간 간격은 하루 중 시간이 없는 양수 또는 음수 일 수 또는 하루 중 시간이 있는 일 수 또는 하루 중 한 시간으로 구성됩니다.

.NET Framework 4부터 구조체는 TimeSpan 값을 문자열 표현으로 변환하는 메서드의 ToString 오버로드를 통해 문화권에 민감한 서식을 지원합니다TimeSpan. 기본 TimeSpan.ToString() 메서드는 이전 버전의 .NET Framework 반환 값과 동일한 고정 형식을 사용하여 시간 간격을 반환합니다. TimeSpan.ToString(String) 오버로드를 사용하면 시간 간격의 문자열 표현을 정의하는 형식 문자열을 지정할 수 있습니다. TimeSpan.ToString(String, IFormatProvider) 오버로드를 사용하면 형식 문자열과 해당 서식 규칙이 시간 간격의 문자열 표현을 만드는 데 사용되는 문화권을 지정할 수 있습니다. TimeSpan 는 표준 및 사용자 지정 형식 문자열을 모두 지원합니다. (자세한 내용은 표준 TimeSpan 형식 문자열 및사용자 지정 TimeSpan 형식 문자열을 참조하세요.) 그러나 표준 형식 문자열만 문화권을 구분합니다.

레거시 TimeSpan 서식 복원

경우에 따라 .NET Framework 3.5 이전 버전의 값 서식을 TimeSpan 성공적으로 지정하는 코드는 .NET Framework 4에서 실패합니다. 이는 TimeSpan_LegacyFormatMode> 요소 메서드를< 호출하여 형식 문자열로 값의 형식을 지정하는 TimeSpan 코드에서 가장 일반적입니다. 다음 예제에서는 .NET Framework 3.5 및 이전 버전에서 값의 서식 TimeSpan 을 성공적으로 지정하지만 .NET Framework 4 이상 버전에서 예외를 throw합니다. .NET Framework 3.5 이전 버전에서 무시되는 지원되지 않는 형식 지정자를 사용하여 값의 서식 TimeSpan 을 지정하려고 합니다.

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

코드를 수정할 수 없는 경우 다음 방법 중 하나로 값의 TimeSpan 레거시 서식을 복원할 수 있습니다.

  • TimeSpan_LegacyFormatMode> 요소가 포함된< 구성 파일을 만듭니다. 이 요소의 enabled 특성을 로 설정하면 true 애플리케이션별로 레거시 TimeSpan 서식이 복원됩니다.

  • "NetFx40_TimeSpanLegacyFormatMode" 호환성을 설정 하 여 애플리케이션 도메인을 만들 때를 전환 합니다. 이렇게 하면 애플리케이션 도메인별로 레거시 TimeSpan 서식을 지정할 수 있습니다. 다음 예제에서는 사용 하는 애플리케이션 도메인에 레거시 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
    

    레거시 돌아갑니다 다음 코드는 새 애플리케이션 도메인에서 실행 되 면 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.
    

생성자

TimeSpan(Int32, Int32, Int32)

TimeSpan 구조체의 새 인스턴스를 지정된 시간, 분, 초의 수로 초기화합니다.

TimeSpan(Int32, Int32, Int32, Int32)

TimeSpan 구조체의 새 인스턴스를 지정된 일, 시간, 분, 초의 수로 초기화합니다.

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

TimeSpan 구조체의 새 인스턴스를 지정된 일, 시간, 분, 초, 밀리초의 수로 초기화합니다.

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

구조체의 TimeSpan 새 인스턴스를 지정된 일 수, 시간, 분, 초, 밀리초 및 마이크로초로 초기화합니다.

TimeSpan(Int64)

TimeSpan 구조체의 새 인스턴스를 지정된 틱 수로 초기화합니다.

필드

MaxValue

최대 TimeSpan 값을 나타냅니다. 이 필드는 읽기 전용입니다.

MinValue

최소 TimeSpan 값을 나타냅니다. 이 필드는 읽기 전용입니다.

NanosecondsPerTick

틱당 나노초 수를 나타냅니다. 이 필드는 상수입니다.

TicksPerDay

1일 동안의 틱 수를 나타냅니다. 이 필드는 상수입니다.

TicksPerHour

1시간 동안의 틱 수를 나타냅니다. 이 필드는 상수입니다.

TicksPerMicrosecond

틱 수를 1 마이크로초로 나타냅니다. 이 필드는 상수입니다.

TicksPerMillisecond

1밀리초 동안의 틱 수를 나타냅니다. 이 필드는 상수입니다.

TicksPerMinute

1분 동안의 틱 수를 나타냅니다. 이 필드는 상수입니다.

TicksPerSecond

1초 동안의 틱 수를 나타냅니다.

Zero

0 TimeSpan 값을 나타냅니다. 이 필드는 읽기 전용입니다.

속성

Days

현재의 TimeSpan 구조체가 나타내는 시간 간격의 일 구성 요소를 가져옵니다.

Hours

현재 TimeSpan 구조체가 나타내는 시간 간격의 시 구성 요소를 가져옵니다.

Microseconds

현재 TimeSpan 구조체가 나타내는 시간 간격의 마이크로초 구성 요소를 가져옵니다.

Milliseconds

현재 TimeSpan 구조가 나타내는 시간 간격의 밀리초 구성 요소를 가져옵니다.

Minutes

현재 TimeSpan 구조가 나타내는 시간 간격의 분 구성 요소를 가져옵니다.

Nanoseconds

현재 TimeSpan 구조체가 나타내는 시간 간격의 나노초 구성 요소를 가져옵니다.

Seconds

현재 TimeSpan 구조가 나타내는 시간 간격의 초 구성 요소를 가져옵니다.

Ticks

현재 TimeSpan 구조체의 값을 나타내는 틱 수를 가져옵니다.

TotalDays

일의 정수 부분과 소수 부분으로 표시된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalHours

시간의 정수 부분과 소수 부분으로 표시된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalMicroseconds

전체 및 소수 마이크로초로 표현된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalMilliseconds

밀리초의 정수 부분과 소수 부분으로 표시된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalMinutes

분의 정수 부분과 소수 부분으로 표시된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalNanoseconds

전체 및 소수 나노초로 표현된 현재 TimeSpan 구조체의 값을 가져옵니다.

TotalSeconds

초의 정수 부분과 소수 부분으로 표시된 현재 TimeSpan 구조체의 값을 가져옵니다.

메서드

Add(TimeSpan)

지정된 TimeSpan 개체와 이 인스턴스의 합을 값으로 갖는 새 TimeSpan 개체를 반환합니다.

Compare(TimeSpan, TimeSpan)

두 개의 TimeSpan 값을 비교하고 첫 번째 값이 두 번째 값보다 짧은지, 같은지, 혹은 긴지를 나타내는 정수를 반환합니다.

CompareTo(Object)

이 인스턴스를 지정된 개체와 비교하고, 이 인스턴스가 지정된 개체보다 짧은지, 같은지, 혹은 긴지를 나타내는 정수를 반환합니다.

CompareTo(TimeSpan)

이 인스턴스를 지정된 TimeSpan 개체와 비교하고, 이 인스턴스가 TimeSpan 개체보다 짧은지, 같은지, 혹은 긴지를 나타내는 정수를 반환합니다.

Divide(Double)

지정된 divisor 및 이 인스턴스의 나누기 결과를 값으로 갖는 새 TimeSpan 개체를 반환합니다.

Divide(TimeSpan)

지정된 ts 및 이 인스턴스의 나누기 결과를 나타내는 새 Double 값을 반환합니다.

Duration()

현재 TimeSpan 개체의 절대 값과 같은 값의 새 TimeSpan 개체를 반환합니다.

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.

Equals(TimeSpan)

이 인스턴스가 지정된 TimeSpan 개체와 같은지 표시하는 값을 반환합니다.

Equals(TimeSpan, TimeSpan)

지정된 TimeSpan의 두 인스턴스가 같은지 여부를 나타내는 값을 반환합니다.

FromDays(Double)

지정된 일 수를 나타내는 TimeSpan을 반환합니다. 여기에서 지정된 값은 밀리초 단위로 반올림됩니다.지정된 값은 밀리초 단위로 반올림됩니다.

FromHours(Double)

지정된 시간의 수를 나타내는 TimeSpan을 반환합니다. 여기에서 지정된 값은 밀리초 단위로 반올림됩니다.

FromMicroseconds(Double)

TimeSpan 지정된 수의 마이크로초를 나타내는 을 반환합니다.

FromMilliseconds(Double)

지정된 밀리초의 수를 나타내는 TimeSpan을 반환합니다.

FromMinutes(Double)

지정된 분의 수를 나타내는 TimeSpan을 반환합니다. 여기에서 지정된 값은 밀리초 단위로 반올림됩니다.

FromSeconds(Double)

지정된 초의 수를 나타내는 TimeSpan을 반환합니다. 여기에서 지정된 값은 밀리초 단위로 반올림됩니다.

FromTicks(Int64)

지정된 시간을 나타내는 TimeSpan을 반환합니다. 여기에서 시간은 틱 단위로 지정됩니다.

GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.

Multiply(Double)

지정된 factor 및 이 인스턴스의 곱하기 결과를 값으로 가지는 새 TimeSpan 개체를 반환합니다.

Negate()

이 인스턴스의 부정 값과 같은 값의 새 TimeSpan 개체를 반환합니다.

Parse(ReadOnlySpan<Char>, IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 시간 간격에 대한 범위 표현을 해당 TimeSpan으로 변환합니다.

Parse(String)

시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다.

Parse(String, IFormatProvider)

지정된 문화권별 형식 정보를 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다.

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

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 문자 범위를 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

ParseExact(String, String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

ParseExact(String, String, IFormatProvider, TimeSpanStyles)

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

ParseExact(String, String[], IFormatProvider)

지정된 형식 문자열 배열 및 문화권별 형식 정보를 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

Subtract(TimeSpan)

지정된 TimeSpan 개체와 이 인스턴스의 차를 값으로 가지는 새 TimeSpan 개체를 반환합니다.

ToString()

현재 TimeSpan 개체의 값을 해당하는 문자열 표현으로 변환합니다.

ToString(String)

지정된 형식을 사용하여 현재 TimeSpan 개체의 값을 해당하는 문자열 표현으로 변환합니다.

ToString(String, IFormatProvider)

지정된 형식과 문화권별 형식 정보를 사용하여 현재 TimeSpan 개체의 값을 해당 문자열 표현으로 변환합니다.

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

현재 시간 범위 숫자 인스턴스 값을 제공된 문자 범위의 형식으로 지정하려고 시도합니다.

TryParse(ReadOnlySpan<Char>, IFormatProvider, TimeSpan)

지정된 문화권별 형식 정보를 사용하여 시간 간격에 대한 범위 표현을 해당 TimeSpan으로 변환하고, 변환에 성공했는지 나타내는 값을 반환합니다.

TryParse(ReadOnlySpan<Char>, TimeSpan)

시간 간격에 대한 범위 표현을 해당 TimeSpan으로 변환하고, 변환에 성공했는지 나타내는 값을 반환합니다.

TryParse(String, IFormatProvider, TimeSpan)

지정된 문화권별 형식 정보를 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환하고, 변환에 성공했는지 여부를 나타내는 값을 반환합니다.

TryParse(String, TimeSpan)

시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환하고, 변환에 성공했는지 여부를 나타내는 값을 반환합니다.

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

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 지정된 범위 표현을 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격에 대한 지정된 범위 표현을 해당 TimeSpan으로 변환하고, 변환에 성공했는지 나타내는 값을 반환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

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

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 지정된 범위 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격의 지정된 범위 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

TryParseExact(String, String, IFormatProvider, TimeSpan)

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격에 대한 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격의 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표현의 형식이 지정된 형식과 정확하게 일치해야 합니다.

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

지정된 형식 및 문화권별 형식 정보를 사용하여 시간 간격의 지정된 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

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

지정된 형식, 문화권별 형식 정보 및 스타일을 사용하여 시간 간격의 지정된 문자열 표현을 해당 TimeSpan으로 변환합니다. 문자열 표시의 형식은 지정된 형식 중 하나와 정확히 일치해야 합니다.

연산자

Addition(TimeSpan, TimeSpan)

두 개의 지정된 TimeSpan 인스턴스를 추가합니다.

Division(TimeSpan, Double)

지정된 divisortimeSpan 인스턴스의 나누기 결과를 값으로 가지는 새 TimeSpan 개체를 반환합니다.

Division(TimeSpan, TimeSpan)

지정된 t2t1 인스턴스의 나누기 결과를 나타내는 새 Double 값을 반환합니다.

Equality(TimeSpan, TimeSpan)

두 개의 TimeSpan 인스턴스가 같은지를 표시합니다.

GreaterThan(TimeSpan, TimeSpan)

지정된 TimeSpan이 지정된 다른 TimeSpan보다 큰지를 표시합니다.

GreaterThanOrEqual(TimeSpan, TimeSpan)

지정된 TimeSpan이 지정된 다른 TimeSpan보다 크거나 같은지를 표시합니다.

Inequality(TimeSpan, TimeSpan)

두 개의 TimeSpan 인스턴스가 같지 않은를 표시합니다.

LessThan(TimeSpan, TimeSpan)

지정된 TimeSpan이 지정된 다른 TimeSpan보다 작은지를 표시합니다.

LessThanOrEqual(TimeSpan, TimeSpan)

지정된 TimeSpan이 지정된 다른 TimeSpan보다 작거나 같은를 표시합니다.

Multiply(Double, TimeSpan)

값이 지정된 factor와 지정된 timeSpan 인스턴스를 곱한 결과인 새 TimeSpan 개체를 반환합니다.

Multiply(TimeSpan, Double)

값이 지정된 timeSpan 인스턴스와 지정된 factor를 곱한 결과인 새 TimeSpan 개체를 반환합니다.

Subtraction(TimeSpan, TimeSpan)

지정된 TimeSpan을 지정된 다른 TimeSpan에서 뺍니다.

UnaryNegation(TimeSpan)

지정된 인스턴스의 부정 값과 같은 값의 TimeSpan을 반환합니다.

UnaryPlus(TimeSpan)

TimeSpan의 지정된 인스턴스를 반환합니다.

명시적 인터페이스 구현

IComparable.CompareTo(Object)

이 인스턴스를 지정된 개체와 비교하고, 이 인스턴스가 지정된 개체보다 짧은지, 같은지, 혹은 긴지를 나타내는 정수를 반환합니다.

적용 대상

추가 정보