C# DataTypes.Date_Time类代码示例

 public Period(Date_Time start, TimeSpan duration)
     : this()
 {
     StartTime = start;
     Duration = new Duration(duration);            
     EndTime = start + duration;
 }

 public Period(DateTime start, DateTime end)
     : this()
 {
     StartTime = new Date_Time(start);
     EndTime = new Date_Time(end);
     Duration = new Duration(start - end);
 }

 public override bool TryParse(string value, ref object obj)
 {
     string[] values = value.Split(',');
     foreach (string v in values)
     {
         object dt = new Date_Time();
         object p = new Period();
         
         //
         // Set the iCalendar for each Date_Time object here,
         // so that any time zones applied to these objects will be
         // handled correctly.
         // NOTE: fixes RRULE30 eval, where EXDATE references a 
         // DATE-TIME without a time zone; therefore, the time zone
         // is implied from DTSTART, and would fail to do a proper
         // time zone lookup, because it wasn't assigned an iCalendar
         // object.
         //
         if (((Date_Time)dt).TryParse(v, ref dt))
         {
             ((Date_Time)dt).iCalendar = iCalendar;
             ((Date_Time)dt).TZID = TZID;
             Items.Add(dt);
         }
         else if (((Period)p).TryParse(v, ref p))
         {
             ((Period)p).StartTime.iCalendar = ((Period)p).EndTime.iCalendar = iCalendar;
             ((Period)p).StartTime.TZID = ((Period)p).EndTime.TZID = TZID;
             Items.Add(p);
         }
         else return false;
     }
     return true;
 }

        public void RRULE1()
        {
            iCalendar iCal = iCalendar.LoadFromFile(@"Calendars\Recurrence\RRULE1.ics");
            Program.TestCal(iCal);
            Event evt = iCal.Events[0];
            List<Occurrence> occurrences = evt.GetOccurrences(
                new Date_Time(2006, 1, 1, tzid, iCal),
                new Date_Time(2011, 1, 1, tzid, iCal));

            Date_Time dt = new Date_Time(2006, 1, 1, 8, 30, 0, tzid, iCal);
            int i = 0;

            while (dt.Year < 2011)
            {
                if ((dt > evt.Start) &&
                    (dt.Year % 2 == 1) && // Every-other year from 2005
                    (dt.Month == 1) &&
                    (dt.DayOfWeek == DayOfWeek.Sunday))
                {
                    Date_Time dt1 = dt.AddHours(1);
                    Assert.AreEqual(dt, occurrences[i].Period.StartTime, "Event should occur at " + dt);
                    Assert.AreEqual(dt1, occurrences[i + 1].Period.StartTime, "Event should occur at " + dt);
                    i += 2;
                }                

                dt = dt.AddDays(1);
            }
        }

        public void TestAlarm(string Calendar, List<Date_Time> Dates, Date_Time Start, Date_Time End)
        {
            iCalendar iCal = iCalendar.LoadFromFile(@"Calendars\Alarm\" + Calendar);
            Program.TestCal(iCal);
            Event evt = (Event)iCal.Events[0];

            Start.iCalendar = iCal;
            Start.TZID = tzid;
            End.iCalendar = iCal;
            End.TZID = tzid;

            evt.Evaluate(Start, End);

            for (int i = 0; i < Dates.Count; i++)
            {
                Dates[i].TZID = tzid;
                Dates[i].iCalendar = iCal;
            }

            // Poll all alarms that occurred between Start and End
            List<DDay.iCal.Components.Alarm.AlarmOccurrence> alarms = evt.PollAlarms();

            foreach (DDay.iCal.Components.Alarm.AlarmOccurrence alarm in alarms)
                Assert.IsTrue(Dates.Contains(alarm.DateTime), "Alarm triggers at " + alarm.DateTime + ", but it should not.");
            Assert.IsTrue(Dates.Count == alarms.Count, "There were " + alarms.Count + " alarm occurrences; there should have been " + Dates.Count + ".");
        }

        public override ArrayList Evaluate(Date_Time FromDate, Date_Time ToDate)
        {
            // Add the event itself, before recurrence rules are evaluated
            if (DTStart != null)
                DateTimes.Add(DTStart);

            return base.Evaluate(FromDate, ToDate);
        }

        public Date_TimeUTCSerializer(Date_Time dt)
            : base(dt)
        {
            // Make a copy of the Date_Time object, so we don't alter
            // the original
            DateTime = dt.Copy();

            // Set the Date_Time object to UTC time
            DateTime.SetKind(DateTimeKind.Utc);            
        }

 public Period(Date_Time start, Date_Time end)
     : this()
 {
     StartTime = start.Copy();
     if (end != null)
     {
         EndTime = end.Copy();
         Duration = new Duration(end.Value - start.Value);
     }            
 }

        public override System.Collections.Generic.List<Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
        {
            if (Start != null)
            {
                Period p = new Period(Start);
                if (!Periods.Contains(p))
                    Periods.Add(p);

                return base.Evaluate(FromDate, ToDate);
            }
            return new System.Collections.Generic.List<Period>();
        }

        public Date_TimeUTCSerializer(Date_Time dt)
            : base(dt)
        {
            // Make a copy of the Date_Time object, so we don't alter
            // the original
            DateTime = dt.Copy();

            // Set the Date_Time object to UTC time
            DateTime = DateTime.UTC;

            // Ensure time is serialized
            DateTime.HasTime = true;
        }

        public Date_TimeUTCSerializer(Date_Time dt)
            : base(dt)
        {
            // Make a copy of the Date_Time object, so we don't alter
            // the original
            DateTime = dt.Copy();

            // Set the Date_Time object to UTC time
            DateTime = DateTime.UTC;

            // FIXME: this is the old way we did it; remove when verified
            //DateTime.SetKind(DateTimeKind.Utc);            
        }

 public static Date_Time AddFrequency(Recur.FrequencyType frequency, Date_Time dt, int interval)
 {
     switch (frequency)
     {
         case Recur.FrequencyType.YEARLY: return dt.AddYears(interval);
         case Recur.FrequencyType.MONTHLY: return dt.AddMonths(interval);
         case Recur.FrequencyType.WEEKLY: return dt.AddDays(interval * 7);
         case Recur.FrequencyType.DAILY: return dt.AddDays(interval);
         case Recur.FrequencyType.HOURLY: return dt.AddHours(interval);
         case Recur.FrequencyType.MINUTELY: return dt.AddMinutes(interval);
         case Recur.FrequencyType.SECONDLY: return dt.AddSeconds(interval);
         default: return dt;
     }
 }

 /// <summary>
 /// Use this method to determine if a todo item has been completed.
 /// This takes into account recurrence items and the previous date
 /// of completion, if any.
 /// </summary>
 /// <param name="DateTime">The date and time to test.</param>
 /// <returns>True if the todo item has been completed</returns>
 public bool IsCompleted(Date_Time currDt)
 {
     if (Status == Status.COMPLETED)
     {
         foreach (Date_Time dt in DateTimes)
         {
             if (dt > Completed && // The item has recurred after it was completed
                 currDt > dt)      // and the current date is after the recurrence date.
                 return false;
         }
         return true;
     }
     return false;
 }

        public ArrayList Evaluate(Date_Time StartDate, Date_Time FromDate, Date_Time EndDate)
        {
            ArrayList Periods = new ArrayList();

            if (StartDate > FromDate)
                FromDate = StartDate;

            if (EndDate < FromDate ||
                FromDate > EndDate)
                return Periods;
            
            foreach (object obj in Items)
                Periods.Add(obj);                

            return Periods;
        }

 /// <summary>
 /// Evaulates the RRule component, and adds each specified DateTime
 /// to the <see cref="Periods"/> collection.
 /// </summary>
 /// <param name="FromDate">The beginning date of the range to evaluate.</param>
 /// <param name="ToDate">The end date of the range to evaluate.</param>
 protected void EvaluateRRule(Date_Time FromDate, Date_Time ToDate)
 {
     // Handle RRULEs
     if (RRule != null)
     {
         foreach (Recur rrule in RRule)
         {
             ArrayList DateTimes = rrule.Evaluate(DTStart, FromDate, ToDate);
             foreach (Date_Time dt in DateTimes)
             {                            
                 if (!this.DateTimes.Contains(dt.Value))
                     this.DateTimes.Add(dt.Value);
             }
         }
     }
 }