public void SerializeCustomZoneWithFloatingDaylightTransitions()
{
var tz3rules = new TimeZoneInfo.AdjustmentRule[] { TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1, 1, 1), new DateTime(9999, 12, 31), TimeSpan.FromMinutes(23), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 58, 0), 3, 2, DayOfWeek.Tuesday), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 6, 2, DayOfWeek.Tuesday)) };
var tz3 = TimeZoneInfo.CreateCustomTimeZone("My Zone 3", TimeSpan.FromHours(-4), "My Zone 3 Name", "My Zone 3 Standard Time", "My Zone 3 Daylight Time", tz3rules);
Assert.AreEqual("My Zone 3;-240;My Zone 3 Name;My Zone 3 Standard Time;My Zone 3 Daylight Time;[01:01:0001;12:31:9999;23;[1;00:00:00;1;1;];[1;00:00:00;12;31;];];", tz3.ToSerializedString());
}
private void CheckIfProblematicTimeZone(DateTime start, DateTime end)
{
try
{
TimeZoneInfo timeZoneInfoById = SPRegionalSettings.GlobalTimeZones.GetZoneInfoById(this.m_orgTZ.ID);
if (timeZoneInfoById.SupportsDaylightSavingTime)
{
TimeZoneInfo.AdjustmentRule[] adjustmentRules = timeZoneInfoById.GetAdjustmentRules();
if (adjustmentRules.Length != 1)
{
int index = this.FindRuleIndex(adjustmentRules, start);
int num2 = this.FindRuleIndex(adjustmentRules, end);
if (index != num2)
{
this.m_problematic = true;
this.m_ruleForStart = adjustmentRules[index];
List <TimeZoneInfo.AdjustmentRule> list = new List <TimeZoneInfo.AdjustmentRule>();
for (int i = 0; i < adjustmentRules.Length; i++)
{
if (i != index)
{
list.Add(adjustmentRules[i]);
}
}
this.m_rules = list.ToArray();
}
}
}
}
catch (Exception)
{
}
}
public void OffsetOutOfRange()
{
TimeZoneInfo.TransitionTime startTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 3, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime endTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 10, 2, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule rule = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2000, 1, 1), new DateTime(2005, 1, 1), new TimeSpan(3, 0, 0), startTransition, endTransition);
TimeZoneInfo.CreateCustomTimeZone("mytimezone", new TimeSpan(12, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { rule });
}
public static void CreateCustomTimeZone_InvalidTimeZone()
{
TimeZoneInfo.TransitionTime s1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 3, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime e1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 10, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime s2 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 2, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime e2 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 11, 2, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule r1 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2000, 1, 1), new DateTime(2005, 1, 1), new TimeSpan(1, 0, 0), s1, e1);
// AdjustmentRules overlap
TimeZoneInfo.AdjustmentRule r2 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2004, 1, 1), new DateTime(2007, 1, 1), new TimeSpan(1, 0, 0), s2, e2);
VerifyCustomTimeZoneException <InvalidTimeZoneException>("mytimezone", new TimeSpan(6, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r1, r2 });
// AdjustmentRules not ordered
TimeZoneInfo.AdjustmentRule r3 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2006, 1, 1), new DateTime(2007, 1, 1), new TimeSpan(1, 0, 0), s2, e2);
VerifyCustomTimeZoneException <InvalidTimeZoneException>("mytimezone", new TimeSpan(6, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r3, r1 });
// Offset out of range
TimeZoneInfo.AdjustmentRule r4 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2000, 1, 1), new DateTime(2005, 1, 1), new TimeSpan(3, 0, 0), s1, e1);
VerifyCustomTimeZoneException <InvalidTimeZoneException>("mytimezone", new TimeSpan(12, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r4 });
// overlapping AdjustmentRules for a date
TimeZoneInfo.AdjustmentRule r5 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2005, 1, 1), new DateTime(2007, 1, 1), new TimeSpan(1, 0, 0), s2, e2);
VerifyCustomTimeZoneException <InvalidTimeZoneException>("mytimezone", new TimeSpan(6, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r1, r5 });
// null AdjustmentRule
VerifyCustomTimeZoneException <InvalidTimeZoneException>("mytimezone", new TimeSpan(12, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { null });
}
private EnhancedAdjustmentRule(TimeZoneInfo.AdjustmentRule rule, TimeSpan baseUtcOffset, TimeSpan baseUtcOffsetDelta, bool forceDaylight)
{
Rule = rule;
ForceDaylight = forceDaylight;
ZoneStandardOffset = baseUtcOffset;
RuleStandardOffset = baseUtcOffset + baseUtcOffsetDelta;
}
/// <summary>
/// Despite holding several adjustment rules, Outlook will only use the rule that is marked as effective.
/// (see http://msdn.microsoft.com/en-us/library/ff960389.aspx )
/// We should ignore all other rules to be consistent with Outlook (all versions).
/// </summary>
public TimeZoneInfo ToTimeZoneInfo()
{
TimeZoneRuleStructure effectiveTimeZoneRuleStructure = GetEffectiveTimeZoneRule();
if (effectiveTimeZoneRuleStructure == null)
{
throw new InvalidPropertyException("No timezone rule has been marked as effective");
}
TimeZoneInfo.AdjustmentRule effectiveTimeZoneRule = effectiveTimeZoneRuleStructure.ToStaticAdjustmentRule();
string standardDisplayName;
string daylightDisplayName;
string timezoneID = KeyName;
if (KeyName == String.Empty)
{
// It's invalid to have an empty timezone ID, use the ID of current timezone
timezoneID = TimeZoneInfo.Local.Id;
}
string displayName = RegistryTimeZoneUtils.GetDisplayName(timezoneID, out standardDisplayName, out daylightDisplayName);
if (effectiveTimeZoneRule == null)
{
// no daylight savings
return(TimeZoneInfo.CreateCustomTimeZone(timezoneID, effectiveTimeZoneRuleStructure.BaseUtcOffset, displayName, standardDisplayName));
}
else
{
TimeZoneInfo.AdjustmentRule[] adjustmentRules = new TimeZoneInfo.AdjustmentRule[] { effectiveTimeZoneRule };
return(TimeZoneInfo.CreateCustomTimeZone(timezoneID, effectiveTimeZoneRuleStructure.BaseUtcOffset, displayName, standardDisplayName, daylightDisplayName, adjustmentRules));
}
}
public void CreateTimeZones()
{
TimeZoneInfo.TransitionTime start = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 1, 0, 0), 3, 5, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime end = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 0, 0), 10, 5, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule rule = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(DateTime.MinValue.Date, DateTime.MaxValue.Date, new TimeSpan(1, 0, 0), start, end);
london = TimeZoneInfo.CreateCustomTimeZone("Europe/London", new TimeSpan(0), "Europe/London", "British Standard Time", "British Summer Time", new TimeZoneInfo.AdjustmentRule [] { rule });
}
public static TimeZoneStructure FromTimeZoneInfo(TimeZoneInfo staticTimeZone)
{
TimeZoneInfo.AdjustmentRule[] rules = staticTimeZone.GetAdjustmentRules();
if (rules.Length > 1)
{
throw new ArgumentException("Cannot create TimeZoneStructure from a time zone with multiple DST rules");
}
TimeZoneStructure structure = new TimeZoneStructure();
if (rules.Length == 0)
{
// no daylight saving
structure.SetBias(staticTimeZone.BaseUtcOffset, new TimeSpan());
structure.stStandardDate = new SystemTime();
structure.stDaylightDate = new SystemTime();
}
else
{
TimeZoneInfo.AdjustmentRule rule = rules[0];
structure.SetBias(staticTimeZone.BaseUtcOffset, rule.DaylightDelta);
structure.stStandardDate = AdjustmentRuleHelper.GetStandardDate(rule);
structure.stDaylightDate = AdjustmentRuleHelper.GetDaylightDate(rule);
}
return(structure);
}
public static DaylightTime GetDaylightChanges(TimeZoneInfo InTimeZoneInfo, int InYear)
{
TimeZoneInfo.AdjustmentRule ruleFound = null;
TimeZoneInfo.AdjustmentRule[] adjustments = InTimeZoneInfo.GetAdjustmentRules();
if (adjustments.Length == 0)
{
throw new Exception(InTimeZoneInfo.StandardName + " has no adjustment rules");
}
//Find the correct adjustment rule
foreach (TimeZoneInfo.AdjustmentRule adjustment in adjustments.OrderByDescending(x => x.DateStart))
{
if (adjustment.DateStart.Year <= InYear)
{
ruleFound = adjustment;
break;
}
}
if (ruleFound == null)
{
throw new Exception("No TimeZoneInfo.AdjustmentRule found for TimeZoneInfo "
+ InTimeZoneInfo.StandardName + " for year " + InYear);
}
DaylightTime outDaylightTime = new DaylightTime(
GetAdjustmentDate(InYear, ruleFound.DaylightTransitionStart)
, GetAdjustmentDate(InYear, ruleFound.DaylightTransitionEnd)
, ruleFound.DaylightDelta);
return(outDaylightTime);
}
private void DefineNonDSTTime()
{
// <Snippet3>
// Define transition times to/from DST
TimeZoneInfo.TransitionTime startTransition, endTransition;
startTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0),
10, 2, DayOfWeek.Sunday);
endTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 3, 0, 0),
3, 2, DayOfWeek.Sunday);
// Define adjustment rule
TimeSpan delta = new TimeSpan(1, 0, 0);
TimeZoneInfo.AdjustmentRule adjustment = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1999, 10, 1),
DateTime.MaxValue.Date, delta, startTransition, endTransition);
// Create array for adjustment rules
TimeZoneInfo.AdjustmentRule[] adjustments = { adjustment };
// Define other custom time zone arguments
string displayName = "(GMT-04:00) Antarctica/Palmer Time";
string standardName = "Palmer Standard Time";
string daylightName = "Palmer Daylight Time";
TimeSpan offset = new TimeSpan(-4, 0, 0);
// Create custom time zone without copying DST information
TimeZoneInfo palmer = TimeZoneInfo.CreateCustomTimeZone(standardName, offset, displayName, standardName,
daylightName, adjustments, true);
// Indicate whether new time zone//s adjustment rules are present
Console.WriteLine("{0} {1}has {2} adjustment rules.",
palmer.StandardName,
!(string.IsNullOrEmpty(palmer.DaylightName)) ? "(" + palmer.DaylightName + ") ": "",
palmer.GetAdjustmentRules().Length);
// Indicate whether new time zone supports DST
Console.WriteLine("{0} supports DST: {1}", palmer.StandardName, palmer.SupportsDaylightSavingTime);
// </Snippet3>
}
/// <summary>
/// Converts a UTC time to a local time based on the TimeZone settings in the meter.
/// </summary>
/// <param name="timeToConvert">The UTC time to convert.</param>
/// <param name="blnDSTEnabled">Whether DST is enabled</param>
/// <param name="lstDSTDates">List of DST date pairs as list of date arrays with two dates in each array.</param>
/// <param name="tsDSTAdjustmentAmount">Timespan to adjust DST by.</param>
/// <param name="tsTimeZoneOffset">timespan to Adjust the timezone by.</param>
/// <returns>The time as a local time.</returns>
// Revision History
// MM/DD/YY who Version Issue# Description
// -------- --- ------- ------ ---------------------------------------------
// 10/18/10 RCG 2.45.06 Created
// 05/18/12 jrf 2.60.23 Refactored method here to share it with another subcontrol.
//
public static DateTime ConvertTimeToLocal(DateTime timeToConvert, bool blnDSTEnabled, List <DateTime[]> lstDSTDates,
TimeSpan tsDSTAdjustmentAmount, TimeSpan tsTimeZoneOffset)
{
DateTime NewTime = timeToConvert;
List <TimeZoneInfo.AdjustmentRule> AdjustmentRules = new List <TimeZoneInfo.AdjustmentRule>();
if (blnDSTEnabled && lstDSTDates != null && lstDSTDates.Count > 0)
{
foreach (DateTime[] adtDSTDatePair in lstDSTDates)
{
TimeZoneInfo.TransitionTime DSTStart = TimeZoneInfo.TransitionTime.CreateFixedDateRule(
new DateTime(1, 1, 1, adtDSTDatePair[TO_DATE].Hour, adtDSTDatePair[TO_DATE].Minute, adtDSTDatePair[TO_DATE].Second),
adtDSTDatePair[TO_DATE].Month, adtDSTDatePair[TO_DATE].Day);
TimeZoneInfo.TransitionTime DSTEnd = TimeZoneInfo.TransitionTime.CreateFixedDateRule(
new DateTime(1, 1, 1, adtDSTDatePair[FROM_DATE].Hour, adtDSTDatePair[FROM_DATE].Minute, adtDSTDatePair[FROM_DATE].Second),
adtDSTDatePair[FROM_DATE].Month, adtDSTDatePair[FROM_DATE].Day);
TimeZoneInfo.AdjustmentRule Rule = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(adtDSTDatePair[TO_DATE].Year, 1, 1, 0, 0, 0),
new DateTime(adtDSTDatePair[TO_DATE].Year, 12, 31, 0, 0, 0), tsDSTAdjustmentAmount, DSTStart, DSTEnd);
AdjustmentRules.Add(Rule);
}
}
TimeZoneInfo MeterTimeZone = TimeZoneInfo.CreateCustomTimeZone("Meter Time", tsTimeZoneOffset, "Meter Time", "Meter Time",
"Meter Time", AdjustmentRules.ToArray(), !blnDSTEnabled);
NewTime = TimeZoneInfo.ConvertTimeFromUtc(timeToConvert, MeterTimeZone);
return(NewTime);
}
internal TimeZoneInfo ToTimeZoneInfo()
{
if (this.daylightTime.HasTransitionTime &&
this.standardTime.HasTransitionTime)
{
TimeZoneInfo.AdjustmentRule adjustmentRule = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(
DateTime.MinValue.Date,
DateTime.MaxValue.Date,
-this.daylightTime.Delta,
this.daylightTime.ToTransitionTime(),
this.standardTime.ToTransitionTime());
return(TimeZoneInfo.CreateCustomTimeZone(
Guid.NewGuid().ToString(),
-this.bias,
"Custom time zone",
"Standard time",
"Daylight time",
new TimeZoneInfo.AdjustmentRule[] { adjustmentRule }));
}
else
{
// Create no DST time zone
return(TimeZoneInfo.CreateCustomTimeZone(
Guid.NewGuid().ToString(),
-this.bias,
"Custom time zone",
"Standard time"));
}
}
// Most code taken from https://github.com/jskeet/DemoCode/blob/main/DateTimeDemos/TimeZoneInfoExplorer/MainForm.cs
private static void DumpRule(TimeZoneInfo zone, TimeZoneInfo.AdjustmentRule rule, bool windowsRules)
{
var start = rule.DateStart.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
var end = rule.DateEnd.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
var delta = FormatOffset(rule.DaylightDelta);
var startTransition = FormatTransition(rule.DaylightTransitionStart);
var endTransition = FormatTransition(rule.DaylightTransitionEnd);
// Work out the start of the transition. This depends on the type of rule.
DateTime ruleStartLocal = windowsRules ? rule.DateStart : rule.DateStart + rule.DaylightTransitionStart.TimeOfDay.TimeOfDay;
DateTime ruleStartUtc = DateTime.SpecifyKind(ruleStartLocal.Year == 1 ? DateTime.MinValue : ruleStartLocal - zone.BaseUtcOffset, DateTimeKind.Utc);
#if NET6_0_OR_GREATER
var baseUtcOffsetDelta = rule.BaseUtcOffsetDelta;
#else
// Effectively fake the BaseUtcOffsetDelta detection for older versions of .NET.
var ruleStandardOffset = zone.GetUtcOffset(ruleStartUtc) - (zone.IsDaylightSavingTime(ruleStartUtc) ? rule.DaylightDelta : TimeSpan.Zero);
var baseUtcOffsetDelta = ruleStandardOffset - zone.BaseUtcOffset;
#endif
var baseUtcOffsetDeltaText = baseUtcOffsetDelta == TimeSpan.Zero ? ""
: $"Base UTC offset delta: {FormatOffset(baseUtcOffsetDelta)}; ";
// Note: while this is "usually okay" there are some rules that don't actually start when we'd predict, which is unfortunate.
bool isDst = zone.IsDaylightSavingTime(ruleStartUtc);
var forceDaylightText = rule.DaylightDelta == TimeSpan.Zero && isDst ? " (force daylight)" : "";
Console.WriteLine($"{start} - {end}: {baseUtcOffsetDeltaText}Daylight delta: {delta}; DST starts {startTransition} and ends {endTransition}{forceDaylightText}");
}
/// <summary>
/// Initializes this transition group based on the specified asjustment rule.
/// </summary>
/// <param name="adjustmentRule">The adjustment rule to initialize from.</param>
/// <param name="standardPeriod">A reference to the pre-created standard period.</param>
internal virtual void InitializeFromAdjustmentRule(TimeZoneInfo.AdjustmentRule adjustmentRule, TimeZonePeriod standardPeriod)
{
TimeZonePeriod daylightPeriod = new TimeZonePeriod();
// Generate an Id of the form "Daylight/2008"
daylightPeriod.Id = string.Format(
"{0}/{1}",
TimeZonePeriod.DaylightPeriodId,
adjustmentRule.DateStart.Year);
daylightPeriod.Name = TimeZonePeriod.DaylightPeriodName;
daylightPeriod.Bias = standardPeriod.Bias - adjustmentRule.DaylightDelta;
this.timeZoneDefinition.Periods.Add(daylightPeriod.Id, daylightPeriod);
this.transitionToDaylight = TimeZoneTransition.CreateTimeZoneTransition(
this.timeZoneDefinition,
daylightPeriod,
adjustmentRule.DaylightTransitionStart);
this.transitionToStandard = TimeZoneTransition.CreateTimeZoneTransition(
this.timeZoneDefinition,
standardPeriod,
adjustmentRule.DaylightTransitionEnd);
this.transitions.Add(this.transitionToDaylight);
this.transitions.Add(this.transitionToStandard);
}
public void SerializeCustomZoneWithFixedDaylightTransitions()
{
var tz4rules = new TimeZoneInfo.AdjustmentRule[] { TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1, 1, 1), new DateTime(9999, 12, 31), TimeSpan.FromMinutes(23), TimeZoneInfo.TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, 2, 15, 59, 48), 3, 2), TimeZoneInfo.TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 6, 2)) };
var tz4 = TimeZoneInfo.CreateCustomTimeZone("My Zone 4", TimeSpan.FromHours(-4), "My Zone 4 Name", "My Zone 4 Standard Time", "My Zone 4 Daylight Time", tz4rules);
Assert.AreEqual("My Zone 4;-240;My Zone 4 Name;My Zone 4 Standard Time;My Zone 4 Daylight Time;[01:01:0001;12:31:9999;23;[1;00:00:00;1;1;];[1;00:00:00;12;31;];];", tz4.ToSerializedString());
}
/// <summary>
/// Initializes this transition group based on the specified asjustment rule.
/// </summary>
/// <param name="adjustmentRule">The adjustment rule to initialize from.</param>
/// <param name="standardPeriod">A reference to the pre-created standard period.</param>
internal virtual void InitializeFromAdjustmentRule(TimeZoneInfo.AdjustmentRule adjustmentRule, TimeZonePeriod standardPeriod)
{
if (adjustmentRule.DaylightDelta.TotalSeconds == 0)
{
// If the time zone info doesn't support Daylight Saving Time, we just need to
// create one transition to one group with one transition to the standard period.
TimeZonePeriod standardPeriodToSet = new TimeZonePeriod();
standardPeriodToSet.Id = string.Format(
"{0}/{1}",
standardPeriod.Id,
adjustmentRule.DateStart.Year);
standardPeriodToSet.Name = standardPeriod.Name;
standardPeriodToSet.Bias = standardPeriod.Bias;
// this.timeZoneDefinition.Periods.Add(standardPeriodToSet.Id, standardPeriodToSet);
this.timeZoneDefinition.Periods[standardPeriodToSet.Id] = standardPeriodToSet;
this.transitionToStandard = new TimeZoneTransition(this.timeZoneDefinition, standardPeriodToSet);
this.transitions.Add(this.transitionToStandard);
}
else
{
TimeZonePeriod daylightPeriod = new TimeZonePeriod();
// Generate an Id of the form "Daylight/2008"
daylightPeriod.Id = string.Format(
"{0}/{1}",
TimeZonePeriod.DaylightPeriodId,
adjustmentRule.DateStart.Year);
daylightPeriod.Name = TimeZonePeriod.DaylightPeriodName;
daylightPeriod.Bias = standardPeriod.Bias - adjustmentRule.DaylightDelta;
// this.timeZoneDefinition.Periods.Add(daylightPeriod.Id, daylightPeriod);
this.timeZoneDefinition.Periods[daylightPeriod.Id] = daylightPeriod;
this.transitionToDaylight = TimeZoneTransition.CreateTimeZoneTransition(
this.timeZoneDefinition,
daylightPeriod,
adjustmentRule.DaylightTransitionStart);
TimeZonePeriod standardPeriodToSet = new TimeZonePeriod();
standardPeriodToSet.Id = string.Format(
"{0}/{1}",
standardPeriod.Id,
adjustmentRule.DateStart.Year);
standardPeriodToSet.Name = standardPeriod.Name;
standardPeriodToSet.Bias = standardPeriod.Bias;
// this.timeZoneDefinition.Periods.Add(standardPeriodToSet.Id, standardPeriodToSet);
this.timeZoneDefinition.Periods[standardPeriodToSet.Id] = standardPeriodToSet;
this.transitionToStandard = TimeZoneTransition.CreateTimeZoneTransition(
this.timeZoneDefinition,
standardPeriodToSet,
adjustmentRule.DaylightTransitionEnd);
this.transitions.Add(this.transitionToDaylight);
this.transitions.Add(this.transitionToStandard);
}
}
public CsnAdjustment(TimeZoneInfo.AdjustmentRule rule)
{
this.StartDate = rule.DateStart;
this.EndDate = rule.DateEnd;
this.DaylightDeltaHours = rule.DaylightDelta.TotalHours;
this.TransitionStart = new CsnTransition(rule.DaylightTransitionStart);
this.TransitionEnd = new CsnTransition(rule.DaylightTransitionEnd);
}
public static Value AdjustmentRule(TimeZoneInfo.AdjustmentRule x) => new Entity
{
[nameof(x.DateEnd)] = DateTime(x.DateEnd),
[nameof(x.DateStart)] = DateTime(x.DateStart),
[nameof(x.DaylightDelta)] = TimeSpan(x.DaylightDelta),
[nameof(x.DaylightTransitionEnd)] = TransitionTime(x.DaylightTransitionEnd),
[nameof(x.DaylightTransitionStart)] = TransitionTime(x.DaylightTransitionStart),
};
private TimeZoneInfo.AdjustmentRule GetCurrentAdjustmentRules(TimeZoneInfo timezone)
{
TimeZoneInfo.AdjustmentRule[] rules = timezone.GetAdjustmentRules();
TimeZoneInfo.AdjustmentRule rule = rules.Last();
DateTime currentDateTime = GetCurrentDateTime();
return((rule.DateEnd > currentDateTime) ? rule : null);
}
public void SupportsDaylightSavingTime_NonEmptyAdjustmentRule_DisableDaylightSavingTime()
{
TimeZoneInfo.TransitionTime s1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 3, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime e1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 10, 2, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule r1 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2000, 1, 1), new DateTime(2005, 1, 1), new TimeSpan(1, 0, 0), s1, e1);
TimeZoneInfo tz = TimeZoneInfo.CreateCustomTimeZone("mytimezone", new TimeSpan(6, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r1 }, true);
Assert.IsFalse(tz.SupportsDaylightSavingTime);
}
public AdjustmentRule(TimeZoneInfo.AdjustmentRule rule)
{
Origin = rule;
DateStart = rule.DateStart;
DateEnd = rule.DateEnd;
DaylightTransitionStart = new TransitionTime(rule.DaylightTransitionStart);
DaylightTransitionEnd = new TransitionTime(rule.DaylightTransitionEnd);
DaylightDelta = rule.DaylightDelta;
}
// Most code taken from https://github.com/jskeet/DemoCode/blob/master/DateTimeDemos/TimeZoneInfoExplorer/MainForm.cs
private static void DumpRule(TimeZoneInfo zone, TimeZoneInfo.AdjustmentRule rule)
{
var start = rule.DateStart.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
var end = rule.DateEnd.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
var delta = FormatOffset(rule.DaylightDelta);
var startTransition = FormatTransition(rule.DaylightTransitionStart);
var endTransition = FormatTransition(rule.DaylightTransitionEnd);
Console.WriteLine($"{start} - {end}: Daylight delta: {delta}; DST starts {startTransition} and ends {endTransition}");
}
/// <summary>
/// The BCL represents "standard-only" rules using two fixed date January 1st transitions.
/// Currently the time-of-day used for the DST end transition is at one millisecond past midnight... we'll
/// be slightly more lenient, accepting anything up to 12:01...
/// </summary>
private static bool IsStandardOffsetOnlyRule(TimeZoneInfo.AdjustmentRule rule)
{
var daylight = rule.DaylightTransitionStart;
var standard = rule.DaylightTransitionEnd;
return(daylight.IsFixedDateRule && daylight.Day == 1 && daylight.Month == 1 &&
daylight.TimeOfDay.TimeOfDay < TimeSpan.FromMinutes(1) &&
standard.IsFixedDateRule && standard.Day == 1 && standard.Month == 1 &&
standard.TimeOfDay.TimeOfDay < TimeSpan.FromMinutes(1));
}
private static TimeSpan DetectStandardOffset(TimeZoneInfo zone, TimeZoneInfo.AdjustmentRule rule)
{
var offset = zone.GetUtcOffset(rule.DateStart);
if (zone.IsDaylightSavingTime(rule.DateStart))
{
offset -= rule.DaylightDelta;
}
return(offset);
}
public void MultiplesRulesForDate()
{
TimeZoneInfo.TransitionTime s1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 3, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime e1 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 10, 2, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule r1 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2000, 1, 1), new DateTime(2005, 1, 1), new TimeSpan(1, 0, 0), s1, e1);
TimeZoneInfo.TransitionTime s2 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 2, 2, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime e2 = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 11, 2, DayOfWeek.Sunday);
TimeZoneInfo.AdjustmentRule r2 = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2005, 1, 1), new DateTime(2007, 1, 1), new TimeSpan(1, 0, 0), s2, e2);
TimeZoneInfo.CreateCustomTimeZone("mytimezone", new TimeSpan(6, 0, 0), null, null, null, new TimeZoneInfo.AdjustmentRule[] { r1, r2 });
}
public void SerializeCustomZoneWithMultipleDaylightRules()
{
var tz5rules = new TimeZoneInfo.AdjustmentRule[] {
TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1, 1, 1), new DateTime(2012, 12, 31), TimeSpan.FromMinutes(23), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 3, 2, DayOfWeek.Tuesday), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 6, 2, DayOfWeek.Tuesday)),
TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(2013, 1, 1), new DateTime(9999, 12, 31), TimeSpan.FromMinutes(48), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 3, 2, DayOfWeek.Tuesday), TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 15, 59, 999), 6, 2, DayOfWeek.Tuesday))
};
var tz5 = TimeZoneInfo.CreateCustomTimeZone("My Zone 5", TimeSpan.FromHours(-6.75), "My Zone 5 Name", "My Zone 5 Standard Time", "My Zone 5 Daylight Time", tz5rules);
Assert.AreEqual("My Zone 5;-405;My Zone 5 Name;My Zone 5 Standard Time;My Zone 5 Daylight Time;[01:01:0001;12:31:2012;23;[1;00:00:00;1;1;];[1;00:00:00;12;31;];][01:01:2013;12:31:9999;48;[1;00:00:00;1;1;];[1;00:00:00;12;31;];];", tz5.ToSerializedString());
}
// <Snippet4>
private TimeZoneInfo InitializeTimeZone()
{
TimeZoneInfo southPole = null;
// Determine if South Pole time zone is defined in system
try
{
southPole = TimeZoneInfo.FindSystemTimeZoneById("Antarctica/South Pole Standard Time");
}
// Time zone does not exist; create it, store it in a text file, and return it
catch
{
const string filename = @".\TimeZoneInfo.txt";
bool found = false;
if (File.Exists(filename))
{
StreamReader reader = new StreamReader(filename);
string timeZoneInfo;
while (reader.Peek() >= 0)
{
timeZoneInfo = reader.ReadLine();
if (timeZoneInfo.Contains("Antarctica/South Pole"))
{
southPole = TimeZoneInfo.FromSerializedString(timeZoneInfo);
reader.Close();
found = true;
break;
}
}
}
if (!found)
{
// Define transition times to/from DST
TimeZoneInfo.TransitionTime startTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 0, 0), 10, 1, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime endTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 0, 0), 3, 3, DayOfWeek.Sunday);
// Define adjustment rule
TimeSpan delta = new TimeSpan(1, 0, 0);
TimeZoneInfo.AdjustmentRule adjustment = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1989, 10, 1), DateTime.MaxValue.Date, delta, startTransition, endTransition);
// Create array for adjustment rules
TimeZoneInfo.AdjustmentRule[] adjustments = { adjustment };
// Define other custom time zone arguments
string displayName = "(GMT+12:00) Antarctica/South Pole";
string standardName = "Antarctica/South Pole Standard Time";
string daylightName = "Antarctica/South Pole Daylight Time";
TimeSpan offset = new TimeSpan(12, 0, 0);
southPole = TimeZoneInfo.CreateCustomTimeZone(standardName, offset, displayName, standardName, daylightName, adjustments);
// Write time zone to the file
StreamWriter writer = new StreamWriter(filename, true);
writer.WriteLine(southPole.ToSerializedString());
writer.Close();
}
}
return(southPole);
}
// https://stackoverflow.com/questions/4764743/get-the-next-date-time-at-which-a-daylight-savings-time-transition-occurs
private (DateTime?, TimeSpan?) GetNextTransition(DateTime asOfTime, TimeZoneInfo timeZone)
{
var adjustments = timeZone.GetAdjustmentRules();
if (adjustments.Length == 0)
{
return(null, null);
}
var year = asOfTime.Year;
TimeZoneInfo.AdjustmentRule adjustment = null;
foreach (var adj in adjustments)
{
// Determine if this adjustment rule covers year desired
if (adj.DateStart.Year <= year && adj.DateEnd.Year >= year)
{
adjustment = adj;
break;
}
}
if (adjustment == null)
{
return(null, null);
}
var dtAdjustmentStart = this.GetAdjustmentDate(adjustment.DaylightTransitionStart, year);
var dtAdjustmentEnd = this.GetAdjustmentDate(adjustment.DaylightTransitionEnd, year);
if (dtAdjustmentStart >= asOfTime)
{
return(dtAdjustmentStart, adjustment.DaylightDelta);
}
if (dtAdjustmentEnd >= asOfTime)
{
return(dtAdjustmentEnd, -adjustment.DaylightDelta);
}
// then it should be the next year's DaylightTransitionStart
year++;
foreach (var adj in adjustments)
{
// Determine if this adjustment rule covers year desired
if (adj.DateStart.Year <= year && adj.DateEnd.Year >= year)
{
adjustment = adj;
break;
}
}
dtAdjustmentStart = this.GetAdjustmentDate(adjustment.DaylightTransitionStart, year);
return(dtAdjustmentStart, adjustment.DaylightDelta);
}
/// <summary>
/// Populate the timezone info and update on UI.
/// </summary>
private void PopulateTimeZones()
{
ReadOnlyCollection <TimeZoneInfo> tzCollection = TimeZoneInfo.GetSystemTimeZones();
List <TimeZoneData> displayNames = new List <TimeZoneData>();
foreach (TimeZoneInfo timeZone in tzCollection)
{
TimeZoneData timeZoneData = new TimeZoneData();
timeZoneData.Id = timeZone.Id;
timeZoneData.DaylightName = timeZone.DaylightName;
timeZoneData.StandardName = timeZone.StandardName;
timeZoneData.DisplayName = timeZone.DisplayName;
timeZoneData.Bias = -1 * (int)timeZone.BaseUtcOffset.TotalMinutes;
TimeZoneInfo.AdjustmentRule[] rules = timeZone.GetAdjustmentRules();
if (rules.Length != 0)
{
TimeZoneInfo.AdjustmentRule currentRule = rules[rules.Length - 1];
int daylightYear = 0;
if (currentRule.DaylightTransitionStart.TimeOfDay.Year != 1) // .net uses 1 so that DateTime accepts it.
{
daylightYear = currentRule.DaylightTransitionStart.TimeOfDay.Year;
}
timeZoneData.DaylightDate = daylightYear +
"-" + currentRule.DaylightTransitionStart.Month.ToString() +
"-" + currentRule.DaylightTransitionStart.Week +
"T" + currentRule.DaylightTransitionStart.TimeOfDay.ToString("HH:mm:ss");
timeZoneData.DaylightBias = -1 * (int)currentRule.DaylightDelta.TotalMinutes;
timeZoneData.DaylightDayOfWeek = (int)currentRule.DaylightTransitionStart.DayOfWeek;
int standardYear = 0;
if (currentRule.DaylightTransitionEnd.TimeOfDay.Year != 1) // .net uses 1 so that DateTime accepts it.
{
standardYear = currentRule.DaylightTransitionEnd.TimeOfDay.Year;
}
timeZoneData.StandardDate = standardYear +
"-" + currentRule.DaylightTransitionEnd.Month.ToString() +
"-" + currentRule.DaylightTransitionEnd.Week +
"T" + currentRule.DaylightTransitionEnd.TimeOfDay.ToString("HH:mm:ss");
timeZoneData.StandardBias = 0;
timeZoneData.StandardDayOfWeek = (int)currentRule.DaylightTransitionEnd.DayOfWeek;
}
displayNames.Add(timeZoneData);
}
TimeZoneCombobox.ItemsSource = displayNames;
TimeZoneCombobox.SelectedIndex = 0;
}
/// <param name="dynamicTimeZone">can be set to null if not available</param>
public override void SetOriginalTimeZone(TimeZoneInfo staticTimeZone, TimeZoneInfo dynamicTimeZone, int effectiveYear)
{
this.TimeZoneDescription = staticTimeZone.DisplayName; // Outlook 2003 RTM writes this for single appointments as well
if (this.File.WriterCompatibilityMode >= WriterCompatibilityMode.Outlook2003SP3)
{
TimeZoneInfo.AdjustmentRule effectiveRule = AdjustmentRuleUtils.GetFirstRule(staticTimeZone);
TimeZoneInfo definitionTimezone = (dynamicTimeZone == null) ? staticTimeZone : dynamicTimeZone;
this.TimeZoneDefinitionStartDisplay = TimeZoneDefinitionStructure.FromTimeZoneInfo(definitionTimezone, effectiveRule, effectiveYear, false);
// We do not set TimeZoneDefinitionEndDisplay, so Outlook will use TimeZoneDefinitionStartDisplay.
}
}
