Condividi tramite


TimeZoneInfo.TransitionTime.IsFixedDateRule Proprietà

Definizione

Ottiene un valore che indica se la modifica dell'ora si verifica a una data e ora fisse, ad esempio il 1° novembre, o a una data e ora mobili, ad esempio l'ultima domenica del mese di ottobre.

public:
 property bool IsFixedDateRule { bool get(); };
public bool IsFixedDateRule { get; }
member this.IsFixedDateRule : bool
Public ReadOnly Property IsFixedDateRule As Boolean

Valore della proprietà

Boolean

true se la regola di modifica dell'ora è basata su una data fissa. false se la regola di modifica dell'ora è basata su una data mobile.

Esempio

Nell'esempio seguente vengono elencati gli orari di transizione da e verso l'ora legale per tutti i fusi orari disponibili nel sistema locale. Per i fusi orari con regole di data fissa, vengono visualizzate informazioni sull'ora di transizione dalle proprietà dell'oggetto TimeZoneInfo.TransitionTime . Per i fusi orari senza regole di data fissa, usa un Calendar oggetto che rappresenta il calendario di sistema corrente per determinare le date di inizio e fine effettive della transizione. Nell'esempio vengono visualizzati i risultati nella console.

private void GetTransitionTimes(int year)
{
   // Instantiate DateTimeFormatInfo object for month names
   DateTimeFormatInfo dateFormat = CultureInfo.CurrentCulture.DateTimeFormat;

   // Get and iterate time zones on local computer
   ReadOnlyCollection<TimeZoneInfo> timeZones = TimeZoneInfo.GetSystemTimeZones();
   foreach (TimeZoneInfo timeZone in timeZones)
   {
      Console.WriteLine("{0}:", timeZone.StandardName);
      TimeZoneInfo.AdjustmentRule[] adjustments = timeZone.GetAdjustmentRules();
      int startYear = year;
      int endYear = startYear;

      if (adjustments.Length == 0)
      {
         Console.WriteLine("   No adjustment rules.");
      }   
      else
      {   
         TimeZoneInfo.AdjustmentRule adjustment = GetAdjustment(adjustments, year);
         if (adjustment == null)
         {
            Console.WriteLine("   No adjustment rules available for this year.");
            continue;
         }
         TimeZoneInfo.TransitionTime startTransition, endTransition;
         
         // Determine if starting transition is fixed 
         startTransition = adjustment.DaylightTransitionStart;
         // Determine if starting transition is fixed and display transition info for year
         if (startTransition.IsFixedDateRule)
            Console.WriteLine("   Begins on {0} {1} at {2:t}", 
                              dateFormat.GetMonthName(startTransition.Month), 
                              startTransition.Day, 
                              startTransition.TimeOfDay);
         else
            DisplayTransitionInfo(startTransition, startYear, "Begins on");

         // Determine if ending transition is fixed and display transition info for year
         endTransition = adjustment.DaylightTransitionEnd;
         
         // Does the transition back occur in an earlier month (i.e., 
         // the following year) than the transition to DST? If so, make
         // sure we have the right adjustment rule.
         if (endTransition.Month < startTransition.Month)
         {
            endTransition = GetAdjustment(adjustments, year + 1).DaylightTransitionEnd;
            endYear++;
         }
      
         if (endTransition.IsFixedDateRule)
            Console.WriteLine("   Ends on {0} {1} at {2:t}", 
                              dateFormat.GetMonthName(endTransition.Month), 
                              endTransition.Day, 
                              endTransition.TimeOfDay);
         else
            DisplayTransitionInfo(endTransition, endYear, "Ends on");
      }      
   }   
} 

private static TimeZoneInfo.AdjustmentRule GetAdjustment(TimeZoneInfo.AdjustmentRule[] adjustments,
                                                  int year)
{                                                  
   // Iterate adjustment rules for time zone
   foreach (TimeZoneInfo.AdjustmentRule adjustment in adjustments)
   {
      // Determine if this adjustment rule covers year desired
      if (adjustment.DateStart.Year <= year && adjustment.DateEnd.Year >= year)
         return adjustment;
   }   
   return null;
}

private void DisplayTransitionInfo(TimeZoneInfo.TransitionTime transition, int year, string label)
{
   // For non-fixed date rules, get local calendar
   Calendar cal = CultureInfo.CurrentCulture.Calendar;
   // Get first day of week for transition
   // For example, the 3rd week starts no earlier than the 15th of the month
   int startOfWeek = transition.Week * 7 - 6;
   // What day of the week does the month start on?
   int firstDayOfWeek = (int) cal.GetDayOfWeek(new DateTime(year, transition.Month, 1)); 
   // Determine how much start date has to be adjusted
   int transitionDay; 
   int changeDayOfWeek = (int) transition.DayOfWeek;

   if (firstDayOfWeek <= changeDayOfWeek)
      transitionDay = startOfWeek + (changeDayOfWeek - firstDayOfWeek);
   else     
      transitionDay = startOfWeek + (7 - firstDayOfWeek + changeDayOfWeek);

   // Adjust for months with no fifth week
   if (transitionDay > cal.GetDaysInMonth(year, transition.Month))  
      transitionDay -= 7;

   Console.WriteLine("   {0} {1}, {2:d} at {3:t}", 
                     label, 
                     transition.DayOfWeek, 
                     new DateTime(year, transition.Month, transitionDay), 
                     transition.TimeOfDay);   
}
open System
open System.Globalization

let displayTransitionInfo (transition: TimeZoneInfo.TransitionTime) year label =
    // For non-fixed date rules, get local calendar
    let cal = CultureInfo.CurrentCulture.Calendar
    // Get first day of week for transition
    // For example, the 3rd week starts no earlier than the 15th of the month
    let startOfWeek = transition.Week * 7 - 6
    // What day of the week does the month start on?
    let firstDayOfWeek = cal.GetDayOfWeek(DateTime(year, transition.Month, 1)) |> int 
    // Determine how much start date has to be adjusted
    let changeDayOfWeek = int transition.DayOfWeek

    let transitionDay = 
        if firstDayOfWeek <= changeDayOfWeek then
            startOfWeek + (changeDayOfWeek - firstDayOfWeek)
        else     
            startOfWeek + (7 - firstDayOfWeek + changeDayOfWeek)

    // Adjust for months with no fifth week
    let transitionDay =
        if transitionDay > cal.GetDaysInMonth(year, transition.Month) then  
            transitionDay - 7
        else 
            transitionDay

    printfn $"   {label} {transition.DayOfWeek}, {DateTime(year, transition.Month, transitionDay):d} at {transition.TimeOfDay:t}"   

let getAdjustment (adjustments: TimeZoneInfo.AdjustmentRule seq) year =
    adjustments
    // Iterate adjustment rules for time zone
    // Determine if this adjustment rule covers year desired
    |> Seq.tryFind (fun adjustment -> adjustment.DateStart.Year <= year && adjustment.DateEnd >= DateTime year)
    |> Option.defaultValue null

let getTransitionTimes year =
    // Instantiate DateTimeFormatInfo object for month names
    let dateFormat = CultureInfo.CurrentCulture.DateTimeFormat

    // Get and iterate time zones on local computer
    let timeZones = TimeZoneInfo.GetSystemTimeZones()
    for timeZone in timeZones do
        printfn $"{timeZone.StandardName}:"
        let adjustments = timeZone.GetAdjustmentRules()
        let startYear = year
        let mutable endYear = startYear

        if adjustments.Length = 0 then
            printfn "   No adjustment rules."
        else
            let adjustment = getAdjustment adjustments year
            if adjustment = null then
                Console.WriteLine("   No adjustment rules available for this year.")
            else
                // Determine if starting transition is fixed 
                let startTransition = adjustment.DaylightTransitionStart
                // Determine if starting transition is fixed and display transition info for year
                if startTransition.IsFixedDateRule then
                    printfn $"   Begins on {dateFormat.GetMonthName startTransition.Month} {startTransition.Day} at {startTransition.TimeOfDay:t}"
                else
                    displayTransitionInfo startTransition startYear "Begins on"

                // Determine if ending transition is fixed and display transition info for year
                let mutable endTransition = adjustment.DaylightTransitionEnd
                
                // Does the transition back occur in an earlier month (i.e., 
                // the following year) than the transition to DST? If so, make
                // sure we have the right adjustment rule.
                if endTransition.Month < startTransition.Month then
                    endTransition <- (getAdjustment adjustments (year + 1)).DaylightTransitionEnd
                    endYear <- endYear + 1
                
                if endTransition.IsFixedDateRule then
                    printfn $"   Ends on {dateFormat.GetMonthName endTransition.Month} {endTransition.Day} at {endTransition.TimeOfDay:t}"
                else
                    displayTransitionInfo endTransition endYear "Ends on"
Private Sub GetTransitionTimes(year As Integer)
   ' Get and iterate time zones on local computer
   Dim timeZones As ReadOnlyCollection(Of TimeZoneInfo) = TimeZoneInfo.GetSystemTimeZones()
   For Each timeZone As TimeZoneInfo In timeZones
      Console.WriteLine("{0}:", timeZone.StandardName)
      Dim adjustments() As TimeZoneInfo.AdjustmentRule = timeZone.GetAdjustmentRules()
      Dim startYear As Integer = year
      Dim endYear As Integer = startYear

      If adjustments.Length = 0 Then
         Console.WriteLine("   No adjustment rules.")
      Else   
         Dim adjustment As TimeZoneInfo.AdjustmentRule = GetAdjustment(adjustments, year)
         If adjustment Is Nothing Then
            Console.WriteLine("   No adjustment rules available for this year.")
            Continue For
         End If
         Dim startTransition, endTransition As TimeZoneInfo.TransitionTime

         ' Determine if starting transition is fixed 
         startTransition = adjustment.DaylightTransitionStart
         ' Determine if starting transition is fixed and display transition info for year
         If startTransition.IsFixedDateRule Then
            Console.WriteLine("   Begins on {0} {1} at {2:t}", _
                              MonthName(startTransition.Month), _
                              startTransition.Day, _
                              startTransition.TimeOfDay)
         Else
            DisplayTransitionInfo(startTransition, startYear, "Begins on")
         End If    

         ' Determine if ending transition is fixed and display transition info for year
         endTransition = adjustment.DaylightTransitionEnd
                
         ' Does the transition back occur in an earlier month (i.e., 
         ' the following year) than the transition to DST? If so, make
         ' sure we have the right adjustment rule.
         If endTransition.Month < startTransition.Month Then
            endTransition = GetAdjustment(adjustments, year + 1).DaylightTransitionEnd
            endYear += 1
         End If

         If endTransition.IsFixedDateRule Then
            Console.WriteLine("   Ends on {0} {1} at {2:t}", _
                              MonthName(endTransition.Month), _
                              endTransition.Day, _
                              endTransition.TimeOfDay)
         Else
            DisplayTransitionInfo(endTransition, endYear, "Ends on")
         End If    
      End If   
   Next 
End Sub

Private Function GetAdjustment(adjustments As TimeZoneInfo.AdjustmentRule(), _
                               year As Integer) As TimeZoneInfo.AdjustmentRule
   ' Iterate adjustment rules for time zone
   For Each adjustment As TimeZoneInfo.AdjustmentRule In adjustments
      ' Determine if this adjustment rule covers year desired
      If adjustment.DateStart.Year <= year And adjustment.DateEnd.Year >= year Then
         Return adjustment
      End If
   Next   
   Return Nothing
End Function
   
Private Sub DisplayTransitionInfo(transition As TimeZoneInfo.TransitionTime, year As Integer, label As String)
   ' For non-fixed date rules, get local calendar
   Static cal As Calendar = CultureInfo.CurrentCulture.Calendar

   ' Get first day of week for transition
   ' For example, the 3rd week starts no earlier than the 15th of the month
   Dim startOfWeek As Integer = transition.Week * 7 - 6
   ' What day of the week does the month start on?
   Dim firstDayOfWeek As Integer = cal.GetDayOfWeek(New Date(year, transition.Month, 1))
   ' Determine how much start date has to be adjusted
   Dim transitionDay As Integer 
   Dim changeDayOfWeek As Integer = transition.DayOfWeek

   If firstDayOfWeek <= changeDayOfWeek Then
      transitionDay = startOfWeek + (changeDayOfWeek - firstDayOfWeek)
   Else     
      transitionDay = startOfWeek + (7 - firstDayOfWeek + changeDayOfWeek)
   End If
   ' Adjust for months with no fifth week
   If transitionDay > cal.GetDaysInMonth(year, transition.Month) Then  
      transitionDay -= 7
   End If
   Console.WriteLine("   {0} {1}, {2:d} at {3:t}", _
                     label, _
                     transition.DayOfWeek, _
                     New DateTime(year, transition.Month, transitionDay), _
                     transition.TimeOfDay)   
End Sub

Commenti

Una regola di data fissa indica che la transizione avviene nella stessa data e ora di ogni anno a cui si applica la regola di rettifica. Ad esempio, una modifica dell'ora che si verifica ogni 3 novembre segue una regola di data fissa. Una regola di data mobile indica che la transizione avviene in un giorno specifico di una settimana specifica di un mese specifico per ogni anno a cui si applica la regola di rettifica. Ad esempio, una modifica dell'ora che si verifica la prima domenica di novembre segue una regola di data mobile.

Il valore della IsFixedDateRule proprietà determina le proprietà di un TimeZoneInfo.TransitionTime oggetto con valori validi. Nella tabella seguente vengono indicate le proprietà interessate dal valore della IsFixedDateRule proprietà .

TransitionTime - proprietà IsFixedDateRule = true IsFixedDateRule = false
Day Valido Non utilizzato
DayOfWeek Non utilizzato Valido
Week Non utilizzato Valido
Month Valido Valido
TimeOfDay Valido Valido

Si applica a