CurrentTimeZone.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / CurrentTimeZone.cs / 1305376 / CurrentTimeZone.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class: CurrentTimeZone 
**
** 
** Purpose:
** This class represents the current system timezone.  It is
** the only meaningful implementation of the TimeZone class
** available in this version. 
**
** The only TimeZone that we support in version 1 is the 
** CurrentTimeZone as determined by the system timezone. 
**
** 
============================================================*/
#if !FEATURE_CORECLR
namespace System {
    using System; 
    using System.Diagnostics.Contracts;
    using System.Text; 
    using System.Threading; 
    using System.Collections;
    using System.Globalization; 
    using System.Runtime.CompilerServices;
    using System.Runtime.Versioning;

    // 
    // Currently, this is the only supported timezone.
    // The values of the timezone is from the current system timezone setting in the 
    // control panel. 
    //
#if FEATURE_CORECLR 
    [Obsolete("System.CurrentSystemTimeZone has been deprecated.  Please investigate the use of System.TimeZoneInfo.Local instead.")]
#endif
    [Serializable]
    internal class CurrentSystemTimeZone : TimeZone { 
        // <
 
 

 


        private const long TicksPerMillisecond = 10000;
        private const long TicksPerSecond = TicksPerMillisecond * 1000; 
        private const long TicksPerMinute = TicksPerSecond * 60;
 
        // The per-year information is cached in in this instance value. As a result it can 
        // be cleaned up by CultureInfo.ClearCachedData, which will clear the instance of this object
        private Hashtable m_CachedDaylightChanges = new Hashtable(); 

        // Standard offset in ticks to the Universal time if
        // no daylight saving is in used.
        // E.g. the offset for PST (Pacific Standard time) should be -8 * 60 * 60 * 1000 * 10000. 
        // (1 millisecond = 10000 ticks)
        private long   m_ticksOffset; 
        private String m_standardName; 
        private String m_daylightName;
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal CurrentSystemTimeZone() {
            m_ticksOffset = nativeGetTimeZoneMinuteOffset() * TicksPerMinute;
            m_standardName = null; 
            m_daylightName = null;
        } 
 
        public override String StandardName {
            [System.Security.SecuritySafeCritical]  // auto-generated 
            get {
                if (m_standardName == null) {
                    m_standardName = nativeGetStandardName();
                } 
                return (m_standardName);
            } 
        } 

        public override String DaylightName { 
            [System.Security.SecuritySafeCritical]  // auto-generated
            get {
                if (m_daylightName == null) {
                    m_daylightName = nativeGetDaylightName(); 
                    if (m_daylightName == null) {
                        m_daylightName = this.StandardName; 
                    } 
                }
                return (m_daylightName); 
            }
        }

        internal long GetUtcOffsetFromUniversalTime(DateTime time, ref Boolean isAmbiguousLocalDst) { 
            // Get the daylight changes for the year of the specified time.
            TimeSpan offset = new TimeSpan(m_ticksOffset); 
            DaylightTime daylightTime = GetDaylightChanges(time.Year); 
            isAmbiguousLocalDst= false;
 
            if (daylightTime == null || daylightTime.Delta.Ticks == 0) {
                return offset.Ticks;
            }
 
            // The start and end times represent the range of universal times that are in DST for that year.
            // Within that there is an ambiguous hour, usually right at the end, but at the beginning in 
            // the unusual case of a negative daylight savings delta. 
            DateTime startTime = daylightTime.Start - offset;
            DateTime endTime = daylightTime.End - offset - daylightTime.Delta; 
            DateTime ambiguousStart;
            DateTime ambiguousEnd;
            if (daylightTime.Delta.Ticks > 0) {
                ambiguousStart = endTime - daylightTime.Delta; 
                ambiguousEnd = endTime;
            } else { 
                ambiguousStart = startTime; 
                ambiguousEnd = startTime - daylightTime.Delta;
            } 

            Boolean isDst = false;
            if (startTime > endTime) {
                // In southern hemisphere, the daylight saving time starts later in the year, and ends in the beginning of next year. 
                // Note, the summer in the southern hemisphere begins late in the year.
                isDst = (time < endTime || time >= startTime); 
            } 
            else {
                // In northern hemisphere, the daylight saving time starts in the middle of the year. 
                isDst = (time>=startTime && time= ambiguousStart && time < ambiguousEnd ) {
                    isAmbiguousLocalDst = true; 
                }
            }
            return offset.Ticks;
        } 

        public override DateTime ToLocalTime(DateTime time) { 
            if (time.Kind == DateTimeKind.Local) { 
                return time;
            } 
            Boolean isAmbiguousLocalDst = false;
            Int64 offset = GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
            long tick = time.Ticks + offset;
            if (tick>DateTime.MaxTicks) { 
                return new DateTime(DateTime.MaxTicks, DateTimeKind.Local);
            } 
            if (tick(ref s_InternalSyncObject, o, null);
                }
                return s_InternalSyncObject;
            } 
        }
 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public override DaylightTime GetDaylightChanges(int year) { 
            if (year < 1 || year > 9999) {
                throw new ArgumentOutOfRangeException("year", Environment.GetResourceString("ArgumentOutOfRange_Range", 1, 9999));
            }
            Contract.EndContractBlock(); 

            Object objYear = (Object)year; 
 
            if (!m_CachedDaylightChanges.Contains(objYear)) {
                lock (InternalSyncObject) { 

                    if (!m_CachedDaylightChanges.Contains(objYear)) {

                        // 
                        // rawData is an array of 17 short (16 bit) numbers.
                        // The first 8 numbers contains the 
                        // year/month/day/dayOfWeek/hour/minute/second/millisecond for the starting time of daylight saving time. 
                        // The next 8 numbers contains the
                        // year/month/day/dayOfWeek/hour/minute/second/millisecond for the ending time of daylight saving time. 
                        // The last short number is the delta to the standard offset in minutes.
                        //
                        short[] rawData = nativeGetDaylightChanges(year);
 
                        if (rawData == null) {
                            // 
                            // If rawData is null, it means that daylight saving time is not used 
                            // in this timezone. So keep currentDaylightChanges as the empty array.
                            // 
                            m_CachedDaylightChanges.Add(objYear, new DaylightTime(DateTime.MinValue, DateTime.MinValue, TimeSpan.Zero));
                        } else {
                            DateTime start;
                            DateTime end; 
                            TimeSpan delta;
 
                            // 
                            // Store the start of daylight saving time.
                            // 

                            start = GetDayOfWeek(year, (rawData[0] != 0), rawData[1], rawData[2],
                                                  rawData[3],
                                                  rawData[4], rawData[5], rawData[6], rawData[7]); 

                            // 
                            // Store the end of daylight saving time. 
                            //
                            end = GetDayOfWeek(year, (rawData[8] != 0), rawData[9], rawData[10], 
                                                rawData[11],
                                                rawData[12], rawData[13], rawData[14], rawData[15]);

                            delta = new TimeSpan(rawData[16] * TicksPerMinute); 
                            DaylightTime currentDaylightChanges = new DaylightTime(start, end, delta);
                            m_CachedDaylightChanges.Add(objYear, currentDaylightChanges); 
                        } 
                    }
                } 
            }

            DaylightTime result = (DaylightTime)m_CachedDaylightChanges[objYear];
 
            return result;
        } 
 
        public override TimeSpan GetUtcOffset(DateTime time) {
            if (time.Kind == DateTimeKind.Utc) { 
                return TimeSpan.Zero;
            }
            else {
                return new TimeSpan(TimeZone.CalculateUtcOffset(time, GetDaylightChanges(time.Year)).Ticks + m_ticksOffset); 
            }
        } 
 
        //
        // Return the (numberOfSunday)th day of week in a particular year/month. 
        //
        private static DateTime GetDayOfWeek(int year, bool fixedDate, int month, int targetDayOfWeek, int numberOfSunday, int hour, int minute, int second, int millisecond) {
            DateTime time;
 
            if (fixedDate) {
                // 
                // Create a Fixed-Date transition time based on the supplied parameters 
                // For Fixed-Dated transition times, the 'numberOfSunday' parameter actually
                // represents the day of the month. 
                //

                // if the day is out of range for the month then use the last day of the month
                int day = DateTime.DaysInMonth(year, month); 

                time = new DateTime(year, month, (day < numberOfSunday) ? day : numberOfSunday, 
                                  hour, minute, second, millisecond, DateTimeKind.Local); 
            }
            else if (numberOfSunday <= 4) { 
                //
                // Get the (numberOfSunday)th Sunday.
                //
 
                time = new DateTime(year, month, 1, hour, minute, second, millisecond, DateTimeKind.Local);
 
                int dayOfWeek = (int)time.DayOfWeek; 
                int delta = targetDayOfWeek - dayOfWeek;
                if (delta < 0) { 
                    delta += 7;
                }
                delta += 7 * (numberOfSunday - 1);
 
                if (delta > 0) {
                    time = time.AddDays(delta); 
                } 
            } else {
                // 
                // If numberOfSunday is greater than 4, we will get the last sunday.
                //
                Calendar cal = GregorianCalendar.GetDefaultInstance();
                time = new DateTime(year, month, cal.GetDaysInMonth(year, month), hour, minute, second, millisecond, DateTimeKind.Local); 
                // This is the day of week for the last day of the month.
                int dayOfWeek = (int)time.DayOfWeek; 
                int delta = dayOfWeek - targetDayOfWeek; 
                if (delta < 0) {
                    delta += 7; 
                }

                if (delta > 0) {
                    time = time.AddDays(-delta); 
                }
            } 
            return (time); 
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int nativeGetTimeZoneMinuteOffset(); 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)] 
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern static String nativeGetDaylightName();
        [System.Security.SecurityCritical]  // auto-generated 
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static String nativeGetStandardName();
        [System.Security.SecurityCritical]  // auto-generated 
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        internal extern static short[] nativeGetDaylightChanges(int year); 
    } // class CurrentSystemTimeZone
} 
#endif // FEATURE_CORECLR

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK