Telerik.Sitefinity.RecurrentRules
Occurrences of this rule repeat on a daily basis.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class DailyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every two days.
DailyRecurrenceRule rrule = new DailyRecurrenceRule(2, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1} ({2})", ix, occurrence.ToLocalTime(), occurrence.DayOfWeek);
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/1/2007 3:30:00 PM (Friday)
2: 6/3/2007 3:30:00 PM (Sunday)
3: 6/5/2007 3:30:00 PM (Tuesday)
4: 6/7/2007 3:30:00 PM (Thursday)
5: 6/9/2007 3:30:00 PM (Saturday)
6: 6/11/2007 3:30:00 PM (Monday)
7: 6/13/2007 3:30:00 PM (Wednesday)
8: 6/15/2007 3:30:00 PM (Friday)
9: 6/17/2007 3:30:00 PM (Sunday)
10: 6/19/2007 3:30:00 PM (Tuesday)
*/
Provides the abstract base class for recurrence rules.
HourlyRecurrenceRule Class
DailyRecurrenceRule Class
WeeklyRecurrenceRule Class
MonthlyRecurrenceRule Class
YearlyRecurrenceRule Class
Notes to implementers: This base class is provided to make it
easier for implementers to create a recurrence rule. Implementers are encouraged to
extend this base class instead of creating their own.
Overriden. Returns the hash code for this instance.
The hash code for this instance.
Overloaded. Overridden. Returns a value indicating whether this instance is equal
to a specified object.
true if value is an instance of
and equals the value of this instance;
otherwise, false.
An object to compare with this instance.
Overloaded. Overridden. Returns a value indicating whether this instance is equal
to a specified object.
true if value equals the value of this instance;
otherwise, false.
An object to compare with this instance.
Determines whether two specified objects have the
same value.
Determines whether two specified objects have
different values.
Specifies the effective range for evaluating occurrences.
End date is before Start date.
The range is inclusive. To clear the effective range call
.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class EffectiveRangeExample
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every 2 hours.
HourlyRecurrenceRule rrule = new HourlyRecurrenceRule(2, range);
// Limits the effective range.
rrule.SetEffectiveRange(Convert.ToDateTime("6/1/2007 5:00 PM"), Convert.ToDateTime("6/1/2007 8:00 PM"));
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/1/2007 5:30:00 PM
2: 6/1/2007 7:30:00 PM
*/
ClearEffectiveRange Method
The starting date of the effective range.
The ending date of the effective range.
Clears the effective range set by calling .
If no effective range was set, calling this method has no effect.
SetEffectiveRange Method
Gets or sets the maximum candidates limit.
This limit is used to prevent lockups when evaluating infinite rules without using SetEffectiveRange.
The default value should not be changed under normal conditions.
The maximum candidates limit.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class DailyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every two days.
DailyRecurrenceRule rrule = new DailyRecurrenceRule(2, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1} ({2})", ix, occurrence.ToLocalTime(), occurrence.DayOfWeek);
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/1/2007 3:30:00 PM (Friday)
2: 6/3/2007 3:30:00 PM (Sunday)
3: 6/5/2007 3:30:00 PM (Tuesday)
4: 6/7/2007 3:30:00 PM (Thursday)
5: 6/9/2007 3:30:00 PM (Saturday)
6: 6/11/2007 3:30:00 PM (Monday)
7: 6/13/2007 3:30:00 PM (Wednesday)
8: 6/15/2007 3:30:00 PM (Friday)
9: 6/17/2007 3:30:00 PM (Sunday)
10: 6/19/2007 3:30:00 PM (Tuesday)
*/
Initializes a new instance of with the
specified interval (in days) and .
The number of days between the occurrences.
The instance that specifies the range of this
recurrence rule.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class DailyRecurrenceRuleExample2
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every week day.
DailyRecurrenceRule rrule = new DailyRecurrenceRule(RecurrenceDay.WeekDays, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1} ({2})", ix, occurrence.ToLocalTime(), occurrence.DayOfWeek);
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/1/2007 3:30:00 PM (Friday)
2: 6/4/2007 3:30:00 PM (Monday)
3: 6/5/2007 3:30:00 PM (Tuesday)
4: 6/6/2007 3:30:00 PM (Wednesday)
5: 6/7/2007 3:30:00 PM (Thursday)
6: 6/8/2007 3:30:00 PM (Friday)
7: 6/11/2007 3:30:00 PM (Monday)
8: 6/12/2007 3:30:00 PM (Tuesday)
9: 6/13/2007 3:30:00 PM (Wednesday)
10: 6/14/2007 3:30:00 PM (Thursday)
*/
Initializes a new instance of with the
specified days of week bit mask and .
A bit mask that specifies the week days on which the event recurs.
The instance that specifies the range of this
recurrence rule.
Provides a helper methods for perfomring different kind of operations over the DateTime objects
This interface defines the ITimeZoneModel.
Occurrences of this rule repeat every given number of hours.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class HourlyRecurrenceRuleExample
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every 2 hours.
HourlyRecurrenceRule rrule = new HourlyRecurrenceRule(2, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/1/2007 3:30:00 PM
2: 6/1/2007 5:30:00 PM
3: 6/1/2007 7:30:00 PM
4: 6/1/2007 9:30:00 PM
5: 6/1/2007 11:30:00 PM
6: 6/2/2007 1:30:00 AM
7: 6/2/2007 3:30:00 AM
8: 6/2/2007 5:30:00 AM
9: 6/2/2007 7:30:00 AM
10: 6/2/2007 9:30:00 AM
*/
Initializes a new instance of the class
with the specified interval (in hours) and .
The number of hours between the occurrences.
The instance that specifies the range of this
recurrence rule.
Provides methods for serializing a recurrence descriptor object in iCal format
and respectively for deserializing an recurrence expression in iCal format into a recurrence descriptor object.
Provides methods for serializing a recurrence descriptor object in certain format
and respectively for deserializing an recurrence expression in certain format into a recurrence descriptor object.
Serialize a recurrence descriptor object into a recurrence expression.
The recurrence descriptor object.
Deserialize a recurrence expression into a recurrence descriptor object.
The recurrence expression.
Deserialize a recurrence expression into a recurrence descriptor object.
The recurrence expression.
object.
Serialize a recurrence descriptor object into a recurrence expression.
The recurrence descriptor object.
Serialized recurrence descriptor.
Creates a recurrence rule with the specified pattern and range.
The recurrence pattern.
The recurrence range.
The constructed recurrence rule.
Creates a recurrence rule instance from it's string representation.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class ParsingExample
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every 2 hours.
HourlyRecurrenceRule rrule = new HourlyRecurrenceRule(2, range);
// Prints the string representation of the recurrence rule:
string rruleAsString = rrule.ToString();
Console.WriteLine("Recurrence rule:\n\n{0}\n", rruleAsString);
// The string representation can be stored in a database, etc.
// ...
// Then it can be reconstructed using TryParse method:
RecurrenceRule parsedRule;
RecurrenceRule.TryParse(rruleAsString, out parsedRule);
Console.WriteLine("After parsing (should be the same):\n\n{0}", parsedRule);
}
}
}
/*
This example produces the following results:
Recurrence rule:
DTSTART:20070601T123000Z
DTEND:20070601T130000Z
RRULE:FREQ=HOURLY;COUNT=10;INTERVAL=2;
After parsing (should be the same):
DTSTART:20070601T123000Z
DTEND:20070601T130000Z
RRULE:FREQ=HOURLY;COUNT=10;INTERVAL=2;
*/
True if input was converted successfully, false otherwise.
The string representation to parse.
When this method returns, contains the recurrence rule instance, if the
conversion succeeded, or null if the conversion failed. The conversion fails if the
value parameter is a null reference (Nothing in Visual Basic)
or represents invalid recurrence rule.
Creates a recurrence rule instance from it's string representation.
The string to parse.
RecurrenceRule if the parsing succeeded or null (Nothing in Visual Basic) if the parsing failed.
See the TryParse overload for more information and examples.
Provides the required information for describing a recurrence rule
Gets the start of the recurring event.
Gets the TimeZone id of the recurring event.
Gets the end date for the recurring event. Defaults to no end date
(DateTime.MaxValue).
Gets the duration of the recurring event.
Gets the limit for the number of occurrences. Defaults to no limit
(Int32.MaxInt).
Gets the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
The default value is 1.
A enumerated constant that indicates the
frequency of recurrence.
Gets the frequency of recurrence.
The default value is .
RecurrenceFrequency Enumeration
Occurrence times are in UTC.
Gets the evaluated occurrence times of this recurrence rule.
The evaluated occurrence times of this recurrence rule.
Gets a collection of the exception dates associated with this recurrence rule.
A collection of the exception dates associated with this recurrence rule.
Gets the bit mask that specifies the week days on which the event
recurs.
RecurrenceDay Enumeration
For additional information on how to create masks see the
documentation.
A bit mask that specifies the week days on which the event recurs.
Gets the day on which the week starts.
This property is only meaningful when is set
to and is greater than 1.
This property is meaningful only when is
set to or
and
is not set.
In such scenario it selects the n-th occurrence within the set of events
specified by the rule. Valid values are from -31 to +31, 0 is ignored.
For example with RecurrenceFrequency set to Monthly and DaysOfWeekMask set to
Monday DayOfMonth is interpreted in the following way:
-
- 1: Selects the first monday of the month.
- 3: Selects the third monday of the month.
- -1: Selects the last monday of the month.
Gets the day month on which the event recurs.
The day month on which the event recurs.
Gets the month on which the event recurs.
This property is only meaningful when is set
to .
Occurrences of this rule repeat on a monthly basis.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class MonthlyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the 5th day of every month.
MonthlyRecurrenceRule rrule = new MonthlyRecurrenceRule(5, 1, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/5/2007 3:30:00 PM
2: 7/5/2007 3:30:00 PM
3: 8/5/2007 3:30:00 PM
4: 9/5/2007 3:30:00 PM
5: 10/5/2007 3:30:00 PM
*/
Initializes a new instance of the class.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class MonthlyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the 5th day of every month.
MonthlyRecurrenceRule rrule = new MonthlyRecurrenceRule(5, 1, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/5/2007 3:30:00 PM
2: 7/5/2007 3:30:00 PM
3: 8/5/2007 3:30:00 PM
4: 9/5/2007 3:30:00 PM
5: 10/5/2007 3:30:00 PM
*/
The day of month on which the event recurs.
The interval (in months) between the occurrences.
The instance that specifies the range of this rule.
Initializes a new instance of the class.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class MonthlyRecurrenceRuleExample2
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the last monday of every two months.
MonthlyRecurrenceRule rrule = new MonthlyRecurrenceRule(-1, RecurrenceDay.Monday, 2, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/25/2007 3:30:00 PM
2: 8/27/2007 3:30:00 PM
3: 10/29/2007 2:30:00 PM
4: 12/31/2007 2:30:00 PM
5: 2/25/2008 2:30:00 PM
*/
The day ordinal modifier. See for additional information.
A bit mask that specifies the week days on which the event recurs.
The interval (in months) between the occurrences.
The instance that specifies the range of this rule.
Specifies the days of the week. Members might be combined using bitwise
operations to specify multiple days.
The constants in the enumeration might be combined
with bitwise operations to represent any combination of days. It is designed to be
used in conjunction with the class to filter
the days of the week for which the recurrence pattern applies.
Consider the following example that demonstrates the basic usage pattern of
RecurrenceDay. The most common operators used for manipulating bit fields
are:
- Bitwise OR: Turns a flag on.
- Bitwise XOR: Toggles a flag.
- Bitwise AND: Checks if a flag is turned on.
- Bitwise NOT: Turns a flag off.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class RecurrenceDayExample
{
static void Main()
{
// Selects Friday, Saturday and Sunday.
RecurrenceDay dayMask = RecurrenceDay.Friday | RecurrenceDay.WeekendDays;
PrintSelectedDays(dayMask);
// Selects all days, except Thursday.
dayMask = RecurrenceDay.EveryDay ^ RecurrenceDay.Thursday;
PrintSelectedDays(dayMask);
}
static void PrintSelectedDays(RecurrenceDay dayMask)
{
Console.WriteLine("Value: {0,3} - {1}", (int) dayMask, dayMask);
}
}
}
/*
This example produces the following results:
Value: 112 - Friday, WeekendDays
Value: 119 - Monday, Tuesday, Wednesday, Friday, WeekendDays
*/
Indicates no selected day.
Indicates Monday.
Indicates Tuesday.
Indicates Wednesday.
Indicates Thursday.
Indicates Friday.
Indicates Saturday.
Indicates Sunday.
Indicates the range from Sunday to Saturday inclusive.
Indicates the range from Monday to Friday inclusive.
Indicates the range from Saturday to Sunday inclusive.
Specifies the frequency of a recurrence.
Indicates no recurrence.
Indicates hourly recurrence.
Indicates daily recurrence.
Indicates weekly recurrence.
Indicates monthly recurrence.
Indicates yearly recurrence.
This class is used as a DTO which is strictly related to the description of a recurrence rule
Specifies the months in which given event recurs.
Indicates no monthly recurrence.
Indicates that the event recurs in January.
Indicates that the event recurs in February.
Indicates that the event recurs in March.
Indicates that the event recurs in April.
Indicates that the event recurs in May.
Indicates that the event recurs in June.
Indicates that the event recurs in July.
Indicates that the event recurs in August.
Indicates that the event recurs in September.
Indicates that the event recurs in October.
Indicates that the event recurs in November.
Indicates that the event recurs in December.
Provides methods for interacting with recurrence rules
Returns a recurrence expression in certain format (iCal by default) calculated basing on the passed object
The recurrence descriptor object
A recurrence expression in certain format (iCal by default)
Tries to parse a recurrence expression in certain format (iCal by default) to a object
A recurrence expression in certain format (iCal by default)
A object
True in case the expression is parsed successfully, otherwise false
Creates hourly recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
Hourly recurrence rule expression in certaing format (iCal by default)
Creates daily recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
Daily recurrence rule expression in certaing format (iCal by default)
Creates daily recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
The bit mask that specifies the week days on which the event recurs
Daily recurrence rule expression in certaing format (iCal by default)
Creates weekly recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
The bit mask that specifies the week days on which the event recurs
Weekly recurrence rule expression in certaing format (iCal by default)
Creates weekly recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
The bit mask that specifies the week days on which the event recurs
The day on which the week starts
Weekly recurrence rule expression in certaing format (iCal by default)
Creates monthy recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
The day month on which the event recurs.
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
Monthy recurrence rule expression in certaing format (iCal by default)
Creates monthy recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
The n-th occurrence within the set of events specified by the rule. Valid values are from -31 to +31, 0 is ignored.
The bit mask that specifies the week days on which the event
the interval of recurrence.
A positive integer representing how often the recurrence rule repeats,
expressed in units.
Monthy recurrence rule expression in certaing format (iCal by default)
Creates yearly recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
The month on which the event recurs
The day month on which the event recurs.
Yearly recurrence rule expression in certaing format (iCal by default)
Creates yearly recurrence rule expression in certaing format (iCal by default)
The start date of the recurrence period
The duration of the recurrence period
The end date of the recurrence period (in case that the maxOccurrences limit is not reached)
The limit for the number of occurrences
The n-th occurrence within the set of events specified by the rule.
The month on which the event recurs
The bit mask that specifies the week days on which the event recurs
Yearly recurrence rule expression in certaing format (iCal by default)
Initializes a new instance of the class.
Initializes a new instance of the class.
The start date and duration are required when deserializing a SharePoint recurrence expression.
The start date.
The duration.
Tries the serialize the descriptor. Returns null if unsuccessful.
The descriptor.
Tries the serialize the descriptor.
The descriptor.
The recurrence.
True if successful
Serializes the descriptor.
The descriptor.
The SharePoint RecurrenceData
Gets the frequency.
The descriptor.
The frequency element of the event.
Creates a recurrence rule instance from it's string representation.
The string to parse.
The start date.
The event duration.
The time zone id.
See the TryParse overload for more information and examples.
RecurrenceRule if the parsing succeeded or null (Nothing in Visual Basic) if the parsing failed.
Creates a recurrence rule instance from it's string representation.
The input string.
The start date.
The event duration.
The time zone id.
The recurrence rule.
Turns RecurrenceData field XML into iCalendar recurrence string.
The recurrence.
The start date.
The event duration.
The time zone id.
Gets the recurrence days.
The options.
The day ordinal.
The day of month.
The rec days.
Turns RecurrenceData options into value for which day of the month (-1, 1, 2, 3, 4)
The options.
Gets the recurrence days dictionary.
Gets the day of week dictionary.
Gets or sets the start date of the recurrence.
The start date.
Gets or sets the duration of the recurrence.
The duration.
Gets or sets the time zone id.
The time zone id.
Occurrences of this rule repeat on a weekly basis.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class WeeklyRecurrenceRuleExample
{
static void Main()
{
// Creates a sample appointment that starts at 6/1/2007 3:30 PM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("6/1/2007 3:30 PM"),
Convert.ToDateTime("6/1/2007 4:00 PM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 10;
// Creates a recurrence rule to repeat the appointment every two weeks on Mondays and Tuesdays.
RecurrenceDay mask = RecurrenceDay.Monday | RecurrenceDay.Tuesday;
WeeklyRecurrenceRule rrule = new WeeklyRecurrenceRule(2, mask, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1} ({2})", ix, occurrence.ToLocalTime(), occurrence.DayOfWeek);
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 6/4/2007 3:30:00 PM (Monday)
2: 6/5/2007 3:30:00 PM (Tuesday)
3: 6/18/2007 3:30:00 PM (Monday)
4: 6/19/2007 3:30:00 PM (Tuesday)
5: 7/2/2007 3:30:00 PM (Monday)
6: 7/3/2007 3:30:00 PM (Tuesday)
7: 7/16/2007 3:30:00 PM (Monday)
8: 7/17/2007 3:30:00 PM (Tuesday)
9: 7/30/2007 3:30:00 PM (Monday)
10: 7/31/2007 3:30:00 PM (Tuesday)
*/
Initializes a new instance of with the
specified interval, days of week bit mask and .
The number of weeks between the occurrences.
A bit mask that specifies the week days on which the event recurs.
The instance that specifies the range of this rule.
Initializes a new instance of with the
specified interval, days of week bit mask and .
The number of weeks between the occurrences.
A bit mask that specifies the week days on which the event recurs.
The instance that specifies the range of this rule.
The first day of week to use for calculations.
Occurrences of this rule repeat on a yearly basis.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class YearlyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 4/1/2007 10:00 AM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("4/1/2007 10:00 AM"),
Convert.ToDateTime("4/1/2007 10:30 AM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the 1th of April each year.
YearlyRecurrenceRule rrule = new YearlyRecurrenceRule(RecurrenceMonth.April, 1, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 4/1/2007 10:00:00 AM
2: 4/1/2008 10:00:00 AM
3: 4/1/2009 10:00:00 AM
4: 4/1/2010 10:00:00 AM
5: 4/1/2011 10:00:00 AM
*/
Initializes a new instance of the class.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class YearlyRecurrenceRuleExample1
{
static void Main()
{
// Creates a sample appointment that starts at 4/1/2007 10:00 AM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("4/1/2007 10:00 AM"),
Convert.ToDateTime("4/1/2007 10:30 AM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the 1th of April each year.
YearlyRecurrenceRule rrule = new YearlyRecurrenceRule(RecurrenceMonth.April, 1, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 4/1/2007 10:00:00 AM
2: 4/1/2008 10:00:00 AM
3: 4/1/2009 10:00:00 AM
4: 4/1/2010 10:00:00 AM
5: 4/1/2011 10:00:00 AM
*/
The month in which the event recurs.
The day of month on which the event recurs.
The instance that specifies the range of this rule.
Initializes a new instance of the class.
using System;
using Telerik.Sitefinity.RecurrentRules;
namespace RecurrenceExamples
{
class YearlyRecurrenceRuleExample2
{
static void Main()
{
// Creates a sample appointment that starts at 4/1/2007 10:00 AM (local time) and lasts half an hour.
Appointment recurringAppointment = new Appointment("1", Convert.ToDateTime("4/1/2007 10:00 AM"),
Convert.ToDateTime("4/1/2007 10:30 AM"), "Sample appointment");
// Creates a recurrence range, that specifies a limit of 10 occurrences for the appointment.
RecurrenceRange range = new RecurrenceRange();
range.Start = recurringAppointment.Start;
range.EventDuration = recurringAppointment.End - recurringAppointment.Start;
range.MaxOccurrences = 5;
// Creates a recurrence rule to repeat the appointment on the second monday of April each year.
YearlyRecurrenceRule rrule = new YearlyRecurrenceRule(2, RecurrenceMonth.April, RecurrenceDay.Monday, range);
Console.WriteLine("Appointment occurrs at the following times: ");
int ix = 0;
foreach (DateTime occurrence in rrule.Occurrences)
{
ix = ix + 1;
Console.WriteLine("{0,2}: {1}", ix, occurrence.ToLocalTime());
}
}
}
}
/*
This example produces the following results:
Appointment occurrs at the following times:
1: 4/9/2007 10:00:00 AM
2: 4/14/2008 10:00:00 AM
3: 4/13/2009 10:00:00 AM
4: 4/12/2010 10:00:00 AM
5: 4/11/2011 10:00:00 AM
*/
The day ordinal modifier. See for additional information.
The month in which the event recurs.
A bit mask that specifies the week days on which the event recurs.
The instance that specifies the range of this rule.