示例#1
0
        static async Task MainAsync(string[] args)
        {
            var tzdb = await CurrentTzdbProvider.LoadAsync();

            var zones = await WriteZonesAsync(tzdb.Ids);

            await WriteLinksAsync(zones, tzdb.Aliases);

            await WriteIntervalsAsync(zones, tzdb);

            await WriteVersion(tzdb.VersionId.Split(' ')[1]);
        }
        private static async Task WriteIntervalsAsync(IDictionary <string, int> zones, CurrentTzdbProvider tzdb)
        {
            var currentUtcYear = SystemClock.Instance.Now.InUtc().Year;
            var maxYear        = currentUtcYear + 5;
            var maxInstant     = new LocalDate(maxYear + 1, 1, 1).AtMidnight().InUtc().ToInstant();

            var links = tzdb.Aliases.SelectMany(x => x).OrderBy(x => x).ToList();

            foreach (var id in tzdb.Ids)
            {
                // Skip noncanonical zones
                if (links.Contains(id))
                {
                    continue;
                }

                using (var dt = new DataTable())
                {
                    dt.Columns.Add("UtcStart", typeof(DateTime));
                    dt.Columns.Add("UtcEnd", typeof(DateTime));
                    dt.Columns.Add("LocalStart", typeof(DateTime));
                    dt.Columns.Add("LocalEnd", typeof(DateTime));
                    dt.Columns.Add("OffsetMinutes", typeof(short));
                    dt.Columns.Add("Abbreviation", typeof(string));

                    var intervals = tzdb[id].GetZoneIntervals(Instant.MinValue, maxInstant);
                    foreach (var interval in intervals)
                    {
                        var utcStart = interval.Start == Instant.MinValue
                            ? DateTime.MinValue
                            : interval.Start.ToDateTimeUtc();

                        var utcEnd = interval.End == Instant.MaxValue
                            ? DateTime.MaxValue
                            : interval.End.ToDateTimeUtc();

                        var localStart = utcStart == DateTime.MinValue
                            ? DateTime.MinValue
                            : interval.IsoLocalStart.ToDateTimeUnspecified();

                        var localEnd = utcEnd == DateTime.MaxValue
                            ? DateTime.MaxValue
                            : interval.IsoLocalEnd.ToDateTimeUnspecified();


                        var offsetMinutes = (short)interval.WallOffset.ToTimeSpan().TotalMinutes;

                        var abbreviation = interval.Name;

                        if (abbreviation.StartsWith("Etc/"))
                        {
                            abbreviation = abbreviation.Substring(4);
                            if (abbreviation.StartsWith("GMT+"))
                            {
                                abbreviation = "GMT-" + abbreviation.Substring(4);
                            }
                            else if (abbreviation.StartsWith("GMT-"))
                            {
                                abbreviation = "GMT+" + abbreviation.Substring(4);
                            }
                        }

                        dt.Rows.Add(utcStart, utcEnd, localStart, localEnd, offsetMinutes, abbreviation);
                    }

                    var cs = _options.ConnectionString;
                    using (var connection = new SqlConnection(cs))
                    {
                        var command = new SqlCommand("[Tzdb].[SetIntervals]", connection)
                        {
                            CommandType = CommandType.StoredProcedure
                        };
                        command.Parameters.AddWithValue("@ZoneId", zones[id]);
                        var tvp = command.Parameters.AddWithValue("@Intervals", dt);
                        tvp.SqlDbType = SqlDbType.Structured;
                        tvp.TypeName  = "[Tzdb].[IntervalTable]";

                        await connection.OpenAsync();

                        await command.ExecuteNonQueryAsync();

                        connection.Close();
                    }
                }
            }
        }