C# TimeZoneInfo.IsAmbiguousTime方法代码示例

		static internal TimeSpan GetUtcOffsetFromUtc (DateTime time, TimeZoneInfo zone, out Boolean isDaylightSavings, out Boolean isAmbiguousLocalDst)
		{
			isDaylightSavings = false;
			isAmbiguousLocalDst = false;
			TimeSpan baseOffset = zone.BaseUtcOffset;

			if (zone.IsAmbiguousTime (time)) {
				isAmbiguousLocalDst = true;
				return baseOffset;
			}

			return zone.GetUtcOffset (time, out isDaylightSavings);
		}

        public static TimeSpan GetUtcOffset(DateTime dateTime, TimeZoneInfo timeZoneInfo)
        {
            // Unlike the default behavior of TimeZoneInfo.GetUtcOffset, it is prefered to choose
            // the DAYLIGHT time when the input is ambiguous, because the daylight instance is the
            // FIRST instance, and time moves in a forward direction.

            TimeSpan offset = timeZoneInfo.IsAmbiguousTime(dateTime)
                ? timeZoneInfo.GetAmbiguousTimeOffsets(dateTime).Max()
                : timeZoneInfo.GetUtcOffset(dateTime);

            return offset;
        }

        //This function identify how many periods has a given date
        private int IdentifyPeriodsByDate(DateTime localDate, TimeZoneInfo timeZone)
        {
            DateTime initDate = localDate.Date;
            DateTime initDateNextDay = initDate.AddDays(1);

            //Inicialmente la variable de retorno tendrá el valor 24 ya que son los periodos normales que tienen casi todos los días
            //(excepto los de cambio de hora)
            int ret = 24;

            bool endFor = false;

            for (DateTime date = initDate; date < initDateNextDay && !endFor; date = date.AddMinutes(5)) // La fecha se incrementa de 5 en 5 min debido a que en ciertas
            // zonas geograficas el cambio de hora puede producirse en horas
            // distintas a horas en punto. (Ejemplo: Producirse el cambio a las
            // 15:30 en una cierta zona, a las 17:45 en otra, etc.)
            {
                //Para evitar que al tratar de convertir en Utc salte una excepción acerca de si su tipo es local y falta atributo sourceTimezone
                date = DateTime.SpecifyKind(date, DateTimeKind.Unspecified);

                //Si date es identificado como ambigüo significa que en esa fecha y hora hay cambio de hora (cuando que quita 1 hora) por lo que ese día
                //tendrá 25 periodos (1 más por la hora repedida del cambio de hora)
                if (timeZone.IsAmbiguousTime(date))
                {
                    endFor = true;
                    ret = 25;
                }
                else
                {
                    try
                    {
                        //Se realiza esta conversión a UTC buscando si salta la excepción.
                        //Esto es porque el día que hay cambio de hora (cuando se añade 1 hora) la hora a la que se le añade "no existe"
                        //por lo que al intentar convertirla a UTC saltará la excepción y sabremos asi que ese día solo tiene 23 periodos
                        //(1 menos por la hora que "no existe")
                        TimeZoneInfo.ConvertTimeToUtc(date, timeZone);
                    }
                    catch (Exception)
                    {
                        endFor = true;
                        ret = 23;
                    }

                }
            }

            return ret;
        }

        private void ProcessMeters(double totalPower,Plant plant, IList<Meter> meterList, IList<SigmaMeasure> sigmaMeasureList, DateTime date, TimeZoneInfo timeZone, int periodsOfDate, string executionResume)
        {
            foreach (SigmaMeasure sigmameasure in sigmaMeasureList)
            {
                Logger.Info(string.Format("Sigma measures ProdutionDate '{0}' and numPeriod {1}", sigmameasure.ProductionDate, sigmameasure.NumPeriod));
            }

            bool[] periodsWithData = new bool[24];
            foreach (var meter in meterList)
            {
                Logger.Info(string.Format("Analyzing sigma measures of meter ID '{0}' and local date {1}", meter.IdMeter, date.ToShortDateString()));

                //Get list of sigma measures of a meter with id 'idMeter' where sigma measure production date (day, month and year) are equal to 'date' var
                var queryDay = from SigmaMeasure in sigmaMeasureList
                               where SigmaMeasure.ProductionDate.Day == date.Day
                               && SigmaMeasure.ProductionDate.Month == date.Month
                               && SigmaMeasure.ProductionDate.Year == date.Year
                               && SigmaMeasure.Id_Meter.Equals(meter.IdMeter)
                               orderby SigmaMeasure.NumPeriod ascending
                               select SigmaMeasure;

                if (queryDay.Count() == 0)
                {
                    Logger.Warn(string.Format("{0} results", queryDay.Count()));
                    executionResume = string.Format("{0}\n\t{1} results", executionResume, queryDay.Count());
                }
                else
                {
                    if (queryDay.Count()==25)
                        periodsWithData = new bool[25];

                    Logger.Info(string.Format("{0} results", queryDay.Count()));
                    Logger.Debug(string.Format("1.Entro"));
                    foreach (SigmaMeasure sm in queryDay)
                    {
                        periodsWithData[sm.NumPeriod] = true;
                    }
                    Logger.Debug(string.Format("2.Entro"));
                    DateTime localDate = date.Date;
                    localDate = DateTime.SpecifyKind(localDate, DateTimeKind.Unspecified);
                    Logger.Debug(string.Format("Entro en initial date '{0}' for converting to UTC with timezone '{1}'", localDate, timeZone));
                    DateTime initialUtcDate = new DateTime();

                    //If localDate is ambiguous date (in daylight saving time when it is converted to UTC could return 2 datetimes,
                    //.Net method 'ConvertTimeToUtc' return second option. This code lines fix it)
                    if (timeZone.IsAmbiguousTime(localDate))
                    {
                        Logger.Warn(string.Format("Ambiguous local time found: {0}.", localDate));
                        executionResume = string.Format("{0}\n\tAmbiguous local time found: {1}.", executionResume, localDate);
                        initialUtcDate = TimeZoneInfo.ConvertTimeToUtc(localDate, timeZone);
                        initialUtcDate.AddHours(-1);
                        Logger.Warn("Ambiguous local time fixed in UTC");
                        executionResume = string.Format("{0}\n\tAmbiguous local time fixed in UTC", executionResume);
                    }
                    else
                    {
                        Logger.Debug(string.Format("Entro en initial date '{0}' for converting to UTC with timezone '{1}'", localDate,timeZone));
                        initialUtcDate = TimeZoneInfo.ConvertTimeToUtc(localDate, timeZone);
                        Logger.Debug(string.Format("Local date '{0}' has been converted to UTC: '{1}'",localDate,initialUtcDate));
                    }

                    int lastNumPeriod = ProcessSigmaMeasure(totalPower, meter, queryDay, initialUtcDate, localDate, executionResume,plant);

                    for (int i = lastNumPeriod + 1; i < periodsOfDate; i++)
                    {
                        Logger.Warn(string.Format("Missing Period Number {0} in meter with ID '{1}' and local date {2}", i, meter.IdMeter, localDate.ToShortDateString()));
                        executionResume = string.Format("{0}\n\tMissing Period Number {1} in meter with ID '{2}' and local date {3}", executionResume, i, meter.IdMeter, localDate.ToShortDateString());
                    }

                }
            }

            String missingPeriods = "";
            for (int i = 0; i < periodsWithData.Count(); i++)
            {
                if (periodsWithData[i] == false)
                {
                    if (missingPeriods.Equals(""))
                    {
                        missingPeriods = string.Format("{0}", i);
                    }
                    else
                    {
                        missingPeriods = string.Format("{0},{1}", missingPeriods, i);
                    }
                }
            }
            if (!missingPeriods.Equals(""))
            {
                if (!idPlantWritedInReport)
                {
                    _wiseReport.AppendFormat("{0};", plant.Id);
                    idPlantWritedInReport = true;
                }
                _wiseReport.AppendFormat("{0};", date.ToString(CultureInfo.GetCultureInfo("es-ES")));
                _wiseReport.AppendFormat("{0};", missingPeriods);
            }
        }

        /// <summary>
        /// Rounds the time to the start of the hour in the specified time zone.
        /// </summary>
        /// <param name="time">The time in UTC.</param>
        /// <param name="timeZone">The time zone. (Can be <see langword="null"/>.)</param>
        /// <param name="localTime">Out: The time in the specified time zone.</param>
        /// <returns>
        /// The start of the day in the specified time zone. The returned value is given in UTC.
        /// </returns>
        /// <remarks>
        /// <para>
        /// The method returns <paramref name="time"/> unchanged if <paramref name="timeZone"/> is
        /// <see cref="TimeZoneInfo.Utc"/> or <see langword="null"/>.
        /// </para>
        /// <para>
        /// <strong>Important:</strong> The returned <paramref name="localTime"/> is valid (i.e. has
        /// an equivalent in UTC), but it may be ambiguous (i.e. has more than one equivalent in
        /// UTC)!
        /// </para>
        /// </remarks>
        private static DateTime RoundToHour(DateTime time, TimeZoneInfo timeZone, out DateTime localTime)
        {
            Debug.Assert(time.Kind == DateTimeKind.Utc, "Time is expected to be UTC.");
            if (timeZone == null || timeZone.Equals(TimeZoneInfo.Utc))
            {
                localTime = time;
                return time;
            }

            // Convert time to specified time zone.
            localTime = TimeZoneInfo.ConvertTime(time, timeZone);

            // Add half an hour for rounding.
            localTime = localTime.AddMinutes(30);

#if SILVERLIGHT
            // Silverlight supports only conversion Local <-> UTC:
            localTime = new DateTime(localTime.Year, localTime.Month, localTime.Day, localTime.Hour, 0, 0, DateTimeKind.Local);
            while (timeZone.IsInvalidTime(localTime))
                localTime = localTime.AddHours(1);

            // When switching back from Daylight Saving Time to normal time, the time in the
            // local time zone is ambiguous and can be mapped to different time values in UTC.
            if (timeZone.IsAmbiguousTime(localTime))
            {
                // Map the local time to the time in UTC which is closest to the original value.
                TimeSpan[] offsets = timeZone.GetAmbiguousTimeOffsets(localTime);
                TimeSpan minDistance = TimeSpan.MaxValue;
                DateTime closestTime = new DateTime();
                foreach (var offset in offsets)
                {
                    DateTime timeUtc = localTime - offset;
                    TimeSpan distance = (timeUtc - time).Duration();
                    if (distance < minDistance)
                    {
                        minDistance = distance;
                        closestTime = timeUtc;
                    }
                }

                time = DateTime.SpecifyKind(closestTime, DateTimeKind.Utc);
            }
            else
            {
                time = TimeZoneInfo.ConvertTime(localTime, TimeZoneInfo.Utc);
            }
#else
            localTime = new DateTime(localTime.Year, localTime.Month, localTime.Day, localTime.Hour, 0, 0);
            while (timeZone.IsInvalidTime(localTime))
                localTime = localTime.AddHours(1);

            // When switching back from Daylight Saving Time to normal time, the time in the 
            // local time zone is ambiguous and can be mapped to different time values in UTC.  
            if (timeZone.IsAmbiguousTime(localTime))
            {
                // Map the local time to the time in UTC which is closest to the original value.
                TimeSpan[] offsets = timeZone.GetAmbiguousTimeOffsets(localTime);
                TimeSpan minDistance = TimeSpan.MaxValue;
                DateTime closestTime = new DateTime();
                foreach (var offset in offsets)
                {
                    DateTime timeUtc = localTime - offset;
                    TimeSpan distance = (timeUtc - time).Duration();
                    if (distance < minDistance)
                    {
                        minDistance = distance;
                        closestTime = timeUtc;
                    }
                }

                time = DateTime.SpecifyKind(closestTime, DateTimeKind.Utc);
            }
            else
            {
                time = TimeZoneInfo.ConvertTime(localTime, timeZone, TimeZoneInfo.Utc);
            }
#endif

            return time;
        }