public DateTime ConvertToUtc(
DateTime localDateTime,
string timeZoneId,
ZoneLocalMappingResolver resolver = null
)
{
if (localDateTime.Kind == DateTimeKind.Utc)
{
return(localDateTime);
}
if (resolver == null)
{
resolver = Resolvers.LenientResolver;
}
var timeZone = tzSource.GetZoneOrNull(timeZoneId);
if (timeZone == null)
{
if (log != null)
{
log.LogWarning("failed to find timezone for " + timeZoneId);
}
return(localDateTime);
}
var local = LocalDateTime.FromDateTime(localDateTime);
var zoned = timeZone.ResolveLocal(local, resolver);
return(zoned.ToDateTimeUtc());
}
/// <summary>
/// CTOR.
/// </summary>
/// <param name="dateTimeZoneProvider"></param>
/// <param name="ianaTimeZoneId">The IANA timezone ID to use for converting.</param>
/// <param name="cultureInfo">The <see cref="CultureInfo"/> to use for converting.</param>
/// <param name="resolver">The <see cref="ZoneLocalMappingResolver"/> to use for converting.</param>
public TimeZoneConverter(IDateTimeZoneProvider dateTimeZoneProvider, string ianaTimeZoneId,
CultureInfo cultureInfo = null, ZoneLocalMappingResolver resolver = null)
{
_dateTimeZoneProvider = dateTimeZoneProvider;
_timeZoneId = ianaTimeZoneId;
_cultureInfo = cultureInfo;
_resolver = resolver;
}
internal ZonedDateTimeParseBucket(ZonedDateTime templateValue, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
Date = new LocalDatePatternParser.LocalDateParseBucket(templateValue.Date);
Time = new LocalTimePatternParser.LocalTimeParseBucket(templateValue.TimeOfDay);
Zone = templateValue.Zone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
internal ZonedDateTimePatternParser(ZonedDateTime templateValue, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
templateValueDate = templateValue.Date;
templateValueTime = templateValue.TimeOfDay;
templateValueZone = templateValue.Zone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
/// <summary>
/// Creates a pattern for the given pattern text, format info, template value, mapping resolver and time zone provider.
/// </summary>
/// <param name="patternText">Pattern text to create the pattern for</param>
/// <param name="formatInfo">The format info to use in the pattern</param>
/// <param name="templateValue">Template value to use for unspecified fields</param>
/// <param name="resolver">Resolver to apply when mapping local date/time values into the zone.</param>
/// <param name="zoneProvider">Time zone provider, used when parsing text which contains a time zone identifier.</param>
/// <returns>A pattern for parsing and formatting zoned date/times.</returns>
/// <exception cref="InvalidPatternException">The pattern text was invalid.</exception>
private static ZonedDateTimePattern Create([NotNull] string patternText, [NotNull] NodaFormatInfo formatInfo,
[NotNull] ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider, ZonedDateTime templateValue)
{
Preconditions.CheckNotNull(patternText, nameof(patternText));
Preconditions.CheckNotNull(formatInfo, nameof(formatInfo));
var pattern = new ZonedDateTimePatternParser(templateValue, resolver, zoneProvider).ParsePattern(patternText, formatInfo);
return(new ZonedDateTimePattern(patternText, formatInfo, templateValue, resolver, zoneProvider, pattern));
}
internal ZonedDateTimeParseBucket(LocalDate templateDate, LocalTime templateTime,
DateTimeZone templateZone, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
Date = new LocalDatePatternParser.LocalDateParseBucket(templateDate);
Time = new LocalTimePatternParser.LocalTimeParseBucket(templateTime);
Zone = templateZone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
private ZonedDateTimePattern(string patternText, NodaFormatInfo formatInfo, ZonedDateTime templateValue,
ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider, IPattern <ZonedDateTime> pattern)
{
this.PatternText = patternText;
this.FormatInfo = formatInfo;
this.TemplateValue = templateValue;
this.Resolver = resolver;
this.ZoneProvider = zoneProvider;
this.pattern = pattern;
}
/// <summary>
/// Creates a pattern for the given pattern text, format info, template value, mapping resolver and time zone provider.
/// </summary>
/// <param name="patternText">Pattern text to create the pattern for</param>
/// <param name="formatInfo">The format info to use in the pattern</param>
/// <param name="templateValue">Template value to use for unspecified fields</param>
/// <param name="resolver">Resolver to apply when mapping local date/time values into the zone.</param>
/// <param name="zoneProvider">Time zone provider, used when parsing text which contains a time zone identifier.</param>
/// <returns>A pattern for parsing and formatting zoned date/times.</returns>
/// <exception cref="InvalidPatternException">The pattern text was invalid.</exception>
internal static ZonedDateTimePattern Create(string patternText, NodaFormatInfo formatInfo,
ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider, ZonedDateTime templateValue)
{
Preconditions.CheckNotNull(patternText, "patternText");
Preconditions.CheckNotNull(formatInfo, "formatInfo");
Preconditions.CheckNotNull(resolver, "resolver");
var pattern = new ZonedDateTimePatternParser(templateValue, resolver, zoneProvider).ParsePattern(patternText, formatInfo);
return(new ZonedDateTimePattern(patternText, formatInfo, templateValue, resolver, zoneProvider, pattern));
}
public static DateTime ConvertUtcToLocation(DateTimeZone dtz, DateTime utc)
{
DateTimeZone utcTimeZone = DateTimeZoneProviders.Tzdb.GetZoneOrNull("UTC");
ZoneLocalMappingResolver customResolver = Resolvers.CreateMappingResolver(Resolvers.ReturnLater, Resolvers.ReturnStartOfIntervalAfter);
var local = LocalDateTime.FromDateTime(utc);
var utcZoned = utcTimeZone.ResolveLocal(local, customResolver);
var locationZoned = utcZoned.ToInstant().InZone(dtz).ToDateTimeUnspecified();
return(locationZoned);
}
/// <summary>
/// Converts the <see cref="DateTime"/> of any <see cref="DateTimeKind"/> to a <see cref="DateTime"/> of <see cref="DateTimeKind.Utc"/>.
/// </summary>
/// <param name="zoneDateTime"></param>
/// <param name="timeZoneId">The ID of the IANA timezone database, https://en.wikipedia.org/wiki/List_of_tz_database_time_zones.</param>
/// <param name="timeZoneProvider"></param>
/// <param name="resolver">The <see cref="ZoneLocalMappingResolver"/> to use. Default is <see cref="Resolvers.LenientResolver"/>´, which never throws an exception due to ambiguity or skipped time.</param>
/// <returns>Returns the converted <see cref="DateTime"/> with <see cref="DateTimeKind.Utc"/> or null, if the <see cref="zoneDateTime"/> parameter is null.</returns>
/// <exception cref="DateTimeZoneNotFoundException">If <see cref="timeZoneId"/> is unknown.</exception>
public static DateTime?ToUtc(DateTime?zoneDateTime, string timeZoneId,
IDateTimeZoneProvider timeZoneProvider = null, ZoneLocalMappingResolver resolver = null)
{
if (!zoneDateTime.HasValue)
{
return(null);
}
timeZoneProvider = timeZoneProvider ?? DateTimeZoneProviders.Tzdb;
// never throws an exception due to ambiguity or skipped time:
if (resolver == null)
{
resolver = Resolvers.LenientResolver;
}
// throws if timeZoneId is unknown
var timeZone = timeZoneProvider[timeZoneId];
var local = LocalDateTime.FromDateTime(zoneDateTime.Value);
var zonedTime = timeZone.ResolveLocal(local, resolver);
return(zonedTime.ToDateTimeUtc());
}
public DateTime ConvertToUtc(
DateTime localDateTime,
string timeZoneId,
ZoneLocalMappingResolver resolver = null
)
{
if (localDateTime.Kind == DateTimeKind.Utc) return localDateTime;
if (resolver == null) resolver = Resolvers.LenientResolver;
var timeZone = tzSource.GetZoneOrNull(timeZoneId);
if (timeZone == null)
{
if (log != null)
{
log.LogWarning("failed to find timezone for " + timeZoneId);
}
return localDateTime;
}
var local = LocalDateTime.FromDateTime(localDateTime);
var zoned = timeZone.ResolveLocal(local, resolver);
return zoned.ToDateTimeUtc();
}
/// <summary>
/// Maps the given <see cref="LocalDateTime"/> to the corresponding <see cref="ZonedDateTime"/>, following
/// the given <see cref="ZoneLocalMappingResolver"/> to handle ambiguity and skipped times.
/// </summary>
/// <remarks>
/// <para>
/// This is a convenience method for calling <see cref="MapLocal"/> and passing the result to the resolver.
/// Common options for resolvers are provided in the static <see cref="Resolvers"/> class.
/// </para>
/// <para>
/// See <see cref="AtStrictly"/> and <see cref="AtLeniently"/> for alternative ways to map a local time to a
/// specific instant.
/// </para>
/// </remarks>
/// <param name="localDateTime">The local date and time to map in this time zone.</param>
/// <param name="resolver">The resolver to apply to the mapping.</param>
/// <returns>The result of resolving the mapping.</returns>
public ZonedDateTime ResolveLocal(LocalDateTime localDateTime, ZoneLocalMappingResolver resolver)
{
Preconditions.CheckNotNull(resolver, nameof(resolver));
return(resolver(MapLocal(localDateTime)));
}
internal ZonedDateTimePatternParser(ZonedDateTime templateValue, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
this.templateValue = templateValue;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
/// <summary>
/// Creates a pattern for the same original pattern text as this pattern, but with the specified
/// resolver.
/// </summary>
/// <param name="newResolver">The new local mapping resolver to use.</param>
/// <returns>A new pattern with the given resolver.</returns>
public ZonedDateTimePattern WithResolver(ZoneLocalMappingResolver newResolver)
{
return(Create(patternText, formatInfo, newResolver, zoneProvider, templateValue));
}
public static DateTime ConvertToUtc(this DateTime localDateTime, string timeZoneId, ZoneLocalMappingResolver resolver = null)
{
if (localDateTime.Kind == DateTimeKind.Utc)
{
return(localDateTime);
}
if (resolver == null)
{
resolver = Resolvers.LenientResolver;
}
var timeZone = TzSource.GetZoneOrNull(timeZoneId);
if (timeZone == null)
{
return(localDateTime);
}
var local = LocalDateTime.FromDateTime(localDateTime);
var zoned = timeZone.ResolveLocal(local, resolver);
return(zoned.ToDateTimeUtc());
}
/// <summary>
/// Creates a pattern for the given pattern text, culture, resolver, time zone provider, and template value.
/// </summary>
/// <remarks>
/// See the user guide for the available pattern text options.
/// If <paramref name="zoneProvider"/> is null, the resulting pattern can be used for formatting
/// but not parsing.
/// </remarks>
/// <param name="patternText">Pattern text to create the pattern for</param>
/// <param name="cultureInfo">The culture to use in the pattern</param>
/// <param name="resolver">Resolver to apply when mapping local date/time values into the zone.</param>
/// <param name="zoneProvider">Time zone provider, used when parsing text which contains a time zone identifier.</param>
/// <param name="templateValue">Template value to use for unspecified fields</param>
/// <returns>A pattern for parsing and formatting zoned date/times.</returns>
/// <exception cref="InvalidPatternException">The pattern text was invalid.</exception>
[NotNull] public static ZonedDateTimePattern Create([NotNull] string patternText, [NotNull] CultureInfo cultureInfo,
[CanBeNull] ZoneLocalMappingResolver resolver, [CanBeNull] IDateTimeZoneProvider zoneProvider, ZonedDateTime templateValue) =>
Create(patternText, NodaFormatInfo.GetFormatInfo(cultureInfo), resolver, zoneProvider, templateValue);
/// <summary>
/// CTOR.
/// </summary>
/// <param name="dateTimeZoneProvider"></param>
/// <param name="timeZoneInfo">The Windows <see cref="TimeZoneInfo"/> to use for converting.</param>
/// <param name="cultureInfo">The <see cref="CultureInfo"/> to use for converting.</param>
/// <param name="resolver">The <see cref="ZoneLocalMappingResolver"/> to use for converting.</param>
public TimeZoneConverter(IDateTimeZoneProvider dateTimeZoneProvider, TimeZoneInfo timeZoneInfo,
CultureInfo cultureInfo = null, ZoneLocalMappingResolver resolver = null) : this(dateTimeZoneProvider,
TzConverter.TZConvert.WindowsToIana(timeZoneInfo.Id), cultureInfo, resolver)
{
}
/// <summary> /// Creates a pattern for the same original pattern text as this pattern, but with the specified /// resolver. /// </summary> /// <param name="resolver">The new local mapping resolver to use.</param> /// <returns>A new pattern with the given resolver.</returns> [NotNull] public ZonedDateTimePattern WithResolver([CanBeNull] ZoneLocalMappingResolver resolver) => Resolver == resolver ? this : Create(PatternText, FormatInfo, resolver, ZoneProvider, TemplateValue);
/// <summary>
/// Creates a pattern for the given pattern text, culture, resolver, time zone provider, and template value.
/// </summary>
/// <remarks>
/// See the user guide for the available pattern text options.
/// If <paramref name="zoneProvider"/> is null, the resulting pattern can be used for formatting
/// but not parsing.
/// </remarks>
/// <param name="patternText">Pattern text to create the pattern for</param>
/// <param name="cultureInfo">The culture to use in the pattern</param>
/// <param name="resolver">Resolver to apply when mapping local date/time values into the zone.</param>
/// <param name="zoneProvider">Time zone provider, used when parsing text which contains a time zone identifier.</param>
/// <param name="templateValue">Template value to use for unspecified fields</param>
/// <returns>A pattern for parsing and formatting zoned date/times.</returns>
/// <exception cref="InvalidPatternException">The pattern text was invalid.</exception>
public static ZonedDateTimePattern Create(string patternText, CultureInfo cultureInfo,
ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider, ZonedDateTime templateValue)
{
return(Create(patternText, NodaFormatInfo.GetFormatInfo(cultureInfo), resolver, zoneProvider, templateValue));
}
