public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
try
{
time = Conversions.ToDate(DateValue);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "DateValue" }));
}
return DatePart(DateIntervalFromString(Interval), time, DayOfWeek, WeekOfYear);
}
// Get the difference between two dates.
public static long DateDiff
(DateInterval Interval, DateTime Date1, DateTime Date2,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
Calendar calendar = CultureInfo.CurrentCulture.Calendar;
switch (Interval)
{
case DateInterval.Year:
return(calendar.GetYear(Date2) -
calendar.GetYear(Date1));
case DateInterval.Quarter:
return((calendar.GetYear(Date2) -
calendar.GetYear(Date1)) * 4 +
((calendar.GetMonth(Date2) - 1) / 3) -
((calendar.GetMonth(Date1) - 1) / 3));
case DateInterval.Month:
return((calendar.GetYear(Date2) -
calendar.GetYear(Date1)) * 12 +
calendar.GetMonth(Date2) -
calendar.GetMonth(Date1));
case DateInterval.DayOfYear:
case DateInterval.Day:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay));
case DateInterval.WeekOfYear:
{
Date1.AddDays(-Weekday(Date1, DayOfWeek));
Date2.AddDays(-Weekday(Date2, DayOfWeek));
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay * 7));
}
// Not reached.
case DateInterval.Weekday:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay * 7));
case DateInterval.Hour:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerHour));
case DateInterval.Minute:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerMinute));
case DateInterval.Second:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerSecond));
}
throw new ArgumentException
(S._("VB_InvalidInterval"), "Interval");
}
private DayOfWeek GetFirstDayOfWeek(FirstDayOfWeek firstDayOfWeek)
{
switch (firstDayOfWeek)
{
case FirstDayOfWeek.Sunday:
return(DayOfWeek.Sunday);
case FirstDayOfWeek.Monday:
return(DayOfWeek.Monday);
case FirstDayOfWeek.Tuesday:
return(DayOfWeek.Tuesday);
case FirstDayOfWeek.Wednesday:
return(DayOfWeek.Wednesday);
case FirstDayOfWeek.Thursday:
return(DayOfWeek.Thursday);
case FirstDayOfWeek.Friday:
return(DayOfWeek.Friday);
case FirstDayOfWeek.Saturday:
return(DayOfWeek.Saturday);
default:
return(CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek);
}
}
public static int DatePart(string Interval, object DateValue,
[Optional, DefaultParameterValue(FirstDayOfWeek.Sunday)] FirstDayOfWeek DayOfWeek,
[Optional, DefaultParameterValue(FirstWeekOfYear.Jan1)] FirstWeekOfYear WeekOfYear)
{
DateTime time;
try
{
time = Conversions.ToDate(DateValue);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "DateValue" }));
}
return(DatePart(DateIntervalFromString(Interval), time, DayOfWeek, WeekOfYear));
}
/// <summary>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</summary>
/// <param name="Interval">Required. <see langword="DateInterval" /> enumeration value or <see langword="String" /> expression representing the part of the date/time value you want to return.</param>
/// <param name="DateValue">Required. <see langword="Date" /> value that you want to evaluate.</param>
/// <param name="DayOfWeek">Optional. A value chosen from the <see langword="FirstDayOfWeek" /> enumeration that specifies the first day of the week. If not specified, <see langword="FirstDayOfWeek.Sunday" /> is used.</param>
/// <param name="WeekOfYear">Optional. A value chosen from the <see langword="FirstWeekOfYear" /> enumeration that specifies the first week of the year. If not specified, <see langword="FirstWeekOfYear.Jan1" /> is used.</param>
/// <returns>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</returns>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="Interval" /> is invalid. </exception>
/// <exception cref="T:System.InvalidCastException">
/// <paramref name="DateValue" /> is not coercible to <see langword="Date" />.</exception>
public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1)
{
DateTime date;
try
{
date = Conversions.ToDate(DateValue);
}
catch (StackOverflowException ex)
{
throw ex;
}
catch (OutOfMemoryException ex)
{
throw ex;
}
catch (ThreadAbortException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[1]
{
nameof(DateValue)
}));
}
return(DateAndTime.DatePart(DateAndTime.DateIntervalFromString(Interval), date, DayOfWeek, WeekOfYear));
}
// Get the name of a specific weekday.
public static String WeekdayName
(int Weekday,
[Optional][DefaultValue(false)] bool Abbreviate,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek FirstDayOfWeekValue)
{
if (Weekday < 1 || Weekday > 7)
{
throw new ArgumentException
(S._("VB_InvalidWeekday"), "Weekday");
}
if (((int)FirstDayOfWeekValue) < 0 ||
((int)FirstDayOfWeekValue) > 7)
{
throw new ArgumentException
(S._("VB_InvalidWeekday"), "FirstDayOfWeekValue");
}
if (FirstDayOfWeekValue == FirstDayOfWeek.System)
{
FirstDayOfWeekValue = SystemFirstDay();
}
int day = (Weekday + (int)FirstDayOfWeekValue - 2) % 7;
if (Abbreviate)
{
return(CultureInfo.CurrentCulture.DateTimeFormat
.GetAbbreviatedDayName((DayOfWeek)day));
}
else
{
return(CultureInfo.CurrentCulture.DateTimeFormat
.GetDayName((DayOfWeek)day));
}
}
/// <summary>
/// Works like Visual Basic WeekDayname method.
/// </summary>
/// <param name="day"></param>
/// <param name="abbreviate"></param>
/// <param name="firstdayofweek"></param>
/// <returns></returns>
public static string WeekDayName(int day, bool abbreviate, FirstDayOfWeek firstdayofweek)
{
string[] _days = { "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday" };
if (day <= _days.Length &&
day > 0)
{
int _selectedday = day + (int)firstdayofweek;
if (_selectedday >= (_days.Length))
{
int _over = _selectedday - _days.Length;
_selectedday = _over;
}
string _day = _days[_selectedday];
if (abbreviate)
{
return(_day.Substring(0, 3));
}
else
{
return(_day);
}
}
else
{
throw new ArgumentException("Day should be between 1 to 7 only.");
}
}
protected virtual void InitializeControls(FirstDayOfWeek firstDayOfWeek)
{
InitRecurrenceControls(firstDayOfWeek);
// Prevent settings from being reset.
SuspendUpdate();
SetRecurrenceType(rinfo.Type);
ResumeUpdate();
}
protected virtual void InitRecurrenceControls(FirstDayOfWeek firstDayOfWeek)
{
weeklyRecurrenceControl1.FirstDayOfWeek = firstDayOfWeek;
dailyRecurrenceControl1.RecurrenceInfo = rinfo;
weeklyRecurrenceControl1.RecurrenceInfo = rinfo;
monthlyRecurrenceControl1.RecurrenceInfo = rinfo;
yearlyRecurrenceControl1.RecurrenceInfo = rinfo;
}
public XtraForm1(Appointment pattern, FirstDayOfWeek fdow, AppointmentFormController afc)
: base(pattern, fdow, afc)
{
//InitializeComponent();
checkEdit1.Tag = RecurrenceType.Hourly;
UnsubscribeRecurrenceTypeControlsEvents();
SubscribeRecurrenceTypeControlsEvents();
SetRecurrenceType(this.GetRecurrenceType());
}
public frmRandevuTekrar(Appointment pattern,
FirstDayOfWeek firstDayOfWeek, AppointmentFormControllerBase controller,
int count)
{
base.spinRangeOccurrencesCount.Value = count;
base.edtRangeStart.DateTime = DateTime.Today;
base.grpRecurrenceRange.Text =
"Range of recurrence: Default Recurrence Count is 7!";
base.Text = "Appointment Recurrence: Modified Form";
}
public static string WeekdayName(int Weekday,
[Optional, DefaultParameterValue(false)] bool Abbreviate,
[Optional, DefaultParameterValue(FirstDayOfWeek.System)]
FirstDayOfWeek FirstDayOfWeekValue)
{
string abbreviatedDayName;
if ((Weekday < 1) || (Weekday > 7))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
if ((FirstDayOfWeekValue < FirstDayOfWeek.System) || (FirstDayOfWeekValue > FirstDayOfWeek.Saturday))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "FirstDayOfWeekValue" }));
}
DateTimeFormatInfo format = (DateTimeFormatInfo)Utils.GetCultureInfo().GetFormat(typeof(DateTimeFormatInfo));
if (FirstDayOfWeekValue == FirstDayOfWeek.System)
{
FirstDayOfWeekValue = (FirstDayOfWeek)(format.FirstDayOfWeek + 1);
}
try
{
if (Abbreviate)
{
abbreviatedDayName = format.GetAbbreviatedDayName((DayOfWeek)(((Weekday + (int)FirstDayOfWeekValue) - 2) % 7));
}
else
{
abbreviatedDayName = format.GetDayName((DayOfWeek)(((Weekday + (int)FirstDayOfWeekValue) - 2) % 7));
}
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
if (abbreviatedDayName.Length == 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
return(abbreviatedDayName);
}
public static int DatePart
(String Interval, Object DateValue,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek FirstDayOfWeekValue,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear FirstWeekOfYearValue)
{
return(DatePart(StringToInterval(Interval),
DateType.FromObject(DateValue),
FirstDayOfWeekValue, FirstWeekOfYearValue));
}
private static int GetDayOfWeek(DateTime dt, FirstDayOfWeek weekdayFirst)
{
if (weekdayFirst < FirstDayOfWeek.System || weekdayFirst > FirstDayOfWeek.Saturday)
{
throw ExceptionUtils.VbMakeException(5);
}
if (weekdayFirst == FirstDayOfWeek.System)
{
weekdayFirst = (FirstDayOfWeek)(Utils.GetDateTimeFormatInfo().FirstDayOfWeek + 1);
}
return(checked (unchecked (checked (unchecked ((int)dt.DayOfWeek) - unchecked ((int)weekdayFirst) + 8) % 7) + 1));
}
private static int GetDayOfWeek(DateTime dt, FirstDayOfWeek weekdayFirst)
{
if ((weekdayFirst < FirstDayOfWeek.System) || (weekdayFirst > FirstDayOfWeek.Saturday))
{
throw ExceptionUtils.VbMakeException(5);
}
if (weekdayFirst == FirstDayOfWeek.System)
{
weekdayFirst = (FirstDayOfWeek)(Utils.GetDateTimeFormatInfo().FirstDayOfWeek + 1);
}
return(((dt.DayOfWeek - ((DayOfWeek)((int)weekdayFirst))) + 8) % (int)(DayOfWeek.Saturday | DayOfWeek.Monday) + 1);
}
/// <summary>
/// Returns the String toFormat formatted with the given mask.
/// </summary>
/// <param name="_toFormat">The String object to format.</param>
/// <param name="_mask">The format to apply.</param>
/// <param name="dayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies the first day of the week.</param>
/// <param name="weekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies the first week of the year.</param>
/// <returns>Empty String if toFormat is null or empty, othewise the formatted string.</returns>
public static String Format(object _toFormat, object _mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
{
//if (_toFormat == null) throw new ArgumentNullException("_toFormat");
//if (_mask == null) throw new ArgumentNullException("_mask");
string toFormat = Convert.ToString(_toFormat);
string mask = PreprocessMask(_toFormat, _mask);
DateTime dt;
if (String.IsNullOrEmpty(toFormat))
{
return(String.Empty);
}
else if (_toFormat is decimal)
{
return(((decimal)_toFormat).ToString(mask));
}
else if (_toFormat is double)
{
return(((double)_toFormat).ToString(mask));
}
else if (_toFormat is float)
{
return(((float)_toFormat).ToString(mask));
}
else if (_toFormat is int)
{
return(((int)_toFormat).ToString(mask));
}
else if (_toFormat is byte)
{
return(((byte)_toFormat).ToString(mask));
}
else if (_toFormat is DateTime)
{
return(((DateTime)_toFormat).ToString(mask));
}
else if (DateTime.TryParse(toFormat, out dt))
{
if (mask == "0")
{
return(dt.ToOADate().ToString());
}
else
{
return(dt.ToString(mask));
}
}
#if WPF || WINFORMS
//UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("VB.Strings.Format");
#endif
return(toFormat);
}
public static long DateDiff
(String Interval, Object Date1, Object Date2,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
return(DateDiff(StringToInterval(Interval),
DateType.FromObject(Date1),
DateType.FromObject(Date2),
DayOfWeek, WeekOfYear));
}
public void SaveToNode(XmlElement e)
{
e.SetAttribute("ISO", ISOCode);
e.SetAttribute("ISO3", ISO3Code);
e.SetAttribute("Fips", Fips);
e.SetAttribute("Name", Name);
e.SetAttribute("Capital", Capital);
e.SetAttribute("Area", Area.ToString());
e.SetAttribute("Population", Population.ToString());
e.SetAttribute("ContinentISOCode", ContinentISOCode);
e.SetAttribute("Neighbours", Neighbours);
e.SetAttribute("FirstDayOfWeek", FirstDayOfWeek.ToString());
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="Interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="DateValue">Date value that you want to evaluate.</param>
/// <param name="DayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="WeekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
if (DateValue == null)
return null;
if (Convert.IsDBNull(DateValue))
return null;
if ((DateValue is string) && (string.IsNullOrEmpty((string)DateValue)))
return null;
return Microsoft.VisualBasic.DateAndTime.DatePart(Interval, Convert.ToDateTime(DateValue), DayOfWeek, WeekOfYear);
}
public void Validate()
{
if (!String.IsNullOrEmpty(Gender) && Gender != "m" && Gender != "f")
{
throw new ArgumentException("Gender");
}
BirthYear.ValidateOptional("BirthYear");
Country.ValidateOptional("Country");
State.ValidateOptional("State");
FirstDayOfWeek.ValidateOptional("FirstDayOfWeek");
Languages.ValidateOptional <Language>("Languages");
}
private static String FormatNumber(object _toFormat, string mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
#endif
{
int intValue = 0;
decimal decimalValue = 0;
bool isInteger = false;
if (_toFormat is DateTime)
{
DateTime dateTime = (DateTime)_toFormat;
decimalValue = new decimal(dateTime.ToOADate());
}
else if (_toFormat is Int32)
{
int toFormatAsInt = (Int32)_toFormat;
intValue = toFormatAsInt;
isInteger = true;
}
else
{
var toFormatAsString = _toFormat.ToString();
#if (NET35)
if (string.IsNullOrEmpty(toFormatAsString) || toFormatAsString.Trim().Length == 0)
#else
if (string.IsNullOrWhiteSpace(toFormatAsString))
#endif
{
return(String.Empty);
}
if (Int32.TryParse(toFormatAsString, out intValue))
{
isInteger = true;
}
else
{
if (!Decimal.TryParse(toFormatAsString, out decimalValue))
{
return(toFormatAsString);
}
}
}
if (mask.Equals("P2", StringComparison.Ordinal))
{
if (isInteger)
{
decimalValue = intValue;
}
return((decimalValue * 100).ToString("F") + "%");
}
return(isInteger ? intValue.ToString(mask, System.Globalization.NumberFormatInfo.CurrentInfo) : decimalValue.ToString(mask, System.Globalization.NumberFormatInfo.CurrentInfo));
}
public static int Weekday(DateTime DateValue, FirstDayOfWeek DayOfWeek = 1)
{
if (DayOfWeek == FirstDayOfWeek.System)
{
DayOfWeek = (FirstDayOfWeek)(DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek + 1);
}
else if ((DayOfWeek < FirstDayOfWeek.Sunday) || (DayOfWeek > FirstDayOfWeek.Saturday))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "DayOfWeek" }));
}
int num = ((int)CurrentCalendar.GetDayOfWeek(DateValue)) + 1;
return((((num - DayOfWeek) + 7) % 7) + 1);
}
/// <summary>Returns an <see langword="Integer" /> value containing a number representing the day of the week.</summary>
/// <param name="DateValue">Required. <see langword="Date" /> value for which you want to determine the day of the week.</param>
/// <param name="DayOfWeek">Optional. A value chosen from the <see langword="FirstDayOfWeek" /> enumeration that specifies the first day of the week. If not specified, <see langword="FirstDayOfWeek.Sunday" /> is used.</param>
/// <returns>Returns an <see langword="Integer" /> value containing a number representing the day of the week.</returns>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="DayOfWeek" /> is less than 0 or more than 7.</exception>
public static int Weekday(DateTime DateValue, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday)
{
if (DayOfWeek == FirstDayOfWeek.System)
{
DayOfWeek = (FirstDayOfWeek)(DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek + 1);
}
else if (DayOfWeek < FirstDayOfWeek.Sunday || DayOfWeek > FirstDayOfWeek.Saturday)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1]
{
nameof(DayOfWeek)
}));
}
return(checked (unchecked (checked ((int)unchecked (DateAndTime.CurrentCalendar.GetDayOfWeek(DateValue) + 1) - unchecked ((int)DayOfWeek) + 7) % 7) + 1));
}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
DateTime time2;
try
{
time = Conversions.ToDate(Date1);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date1" }));
}
try
{
time2 = Conversions.ToDate(Date2);
}
catch (StackOverflowException exception4)
{
throw exception4;
}
catch (OutOfMemoryException exception5)
{
throw exception5;
}
catch (ThreadAbortException exception6)
{
throw exception6;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date2" }));
}
return(DateDiff(DateIntervalFromString(Interval), time, time2, DayOfWeek, WeekOfYear));
}
public static long DateDiff(
DateInterval Interval, DateTime Date1, DateTime Date2,
[Optional, DefaultParameterValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional, DefaultParameterValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
Calendar currentCalendar;
TimeSpan span = Date2.Subtract(Date1);
switch (Interval)
{
case DateInterval.Year:
currentCalendar = CurrentCalendar;
return((long)(currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)));
case DateInterval.Quarter:
currentCalendar = CurrentCalendar;
return((long)((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 4) + ((currentCalendar.GetMonth(Date2) - 1) / 3)) - ((currentCalendar.GetMonth(Date1) - 1) / 3)));
case DateInterval.Month:
currentCalendar = CurrentCalendar;
return((long)((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 12) + currentCalendar.GetMonth(Date2)) - currentCalendar.GetMonth(Date1)));
case DateInterval.DayOfYear:
case DateInterval.Day:
return((long)Math.Round(Conversion.Fix(span.TotalDays)));
case DateInterval.WeekOfYear:
Date1 = Date1.AddDays((double)(0 - GetDayOfWeek(Date1, DayOfWeek)));
Date2 = Date2.AddDays((double)(0 - GetDayOfWeek(Date2, DayOfWeek)));
return(((long)Math.Round(Conversion.Fix(Date2.Subtract(Date1).TotalDays))) / 7L);
case DateInterval.Weekday:
return(((long)Math.Round(Conversion.Fix(span.TotalDays))) / 7L);
case DateInterval.Hour:
return((long)Math.Round(Conversion.Fix(span.TotalHours)));
case DateInterval.Minute:
return((long)Math.Round(Conversion.Fix(span.TotalMinutes)));
case DateInterval.Second:
return((long)Math.Round(Conversion.Fix(span.TotalSeconds)));
}
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
private void LoadAppointments()
{
DateTime startDate = FirstDayOfWeek.GetFirstDayOfWeek(DateTime.Now);
DateTime endDate = startDate.AddDays(7);
CalendarFolder calendar = FindDefaultCalendarFolder();
CalendarView cView = new CalendarView(startDate, endDate, 50);
cView.PropertySet = new PropertySet(AppointmentSchema.Subject, AppointmentSchema.Start, AppointmentSchema.End, AppointmentSchema.Id);
FindItemsResults <Appointment> appointments = calendar.FindAppointments(cView);
foreach (Appointment appointment in appointments)
{
Console.WriteLine("Subject: " + appointment.Subject);
}
}
public MyAppointmentRecurrenceForm(SchedulerControl scheduler_control,
Appointment apt)
{
InitializeComponent();
// Create a controller instance.
controller = new AppointmentFormController(scheduler_control, apt);
// Get an appointment pattern copy.
patternCopy = controller.PrepareToRecurrenceEdit();
// Get access to the recurrence information.
this.rinfo = patternCopy.RecurrenceInfo;
// Get the first day of the week.
firstDayOfWeek = scheduler_control.OptionsView.FirstDayOfWeek;
radioGroup1.EditValueChanged += radioGroup1_EditValueChanged;
btnOK.Click += btnOK_Click;
btnCancel.Click += btnCancel_Click;
InitializeControls(firstDayOfWeek);
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="Interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="DateValue">Date value that you want to evaluate.</param>
/// <param name="DayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="WeekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
if (DateValue == null)
{
return(null);
}
if (Convert.IsDBNull(DateValue))
{
return(null);
}
if ((DateValue is string) && (string.IsNullOrEmpty((string)DateValue)))
{
return(null);
}
return(Microsoft.VisualBasic.DateAndTime.DatePart(Interval, Convert.ToDateTime(DateValue), DayOfWeek, WeekOfYear));
}
public override int GetHashCode()
{
var hashCode = ByDay.GetHashCode() ^ ByHour.GetHashCode() ^ ByMinute.GetHashCode() ^ ByMonth.GetHashCode() ^ ByMonthDay.GetHashCode() ^
BySecond.GetHashCode() ^ BySetPosition.GetHashCode() ^ ByWeekNo.GetHashCode() ^ ByYearDay.GetHashCode() ^ Count.GetHashCode() ^
Frequency.GetHashCode();
if (Interval.Equals(1))
{
hashCode ^= 0x1;
}
else
{
hashCode ^= Interval.GetHashCode();
}
hashCode ^= Until.GetHashCode();
hashCode ^= FirstDayOfWeek.GetHashCode();
return(hashCode);
}
// Get the weekday from a date value.
public static int Weekday
(DateTime DateValue,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek)
{
if (DayOfWeek == FirstDayOfWeek.System)
{
DayOfWeek = SystemFirstDay();
}
if (((int)DayOfWeek) < 1 || ((int)DayOfWeek) > 7)
{
throw new ArgumentException
(S._("VB_InvalidWeekday"), "DayOfWeek");
}
int day = (int)(CultureInfo.CurrentCulture.Calendar
.GetDayOfWeek(DateValue)) + 1;
return(((day - (int)DayOfWeek + 7) % 7) + 1);
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="dateValue">Date value that you want to evaluate.</param>
/// <param name="dayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="weekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string interval, object dateValue, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
{
if (dateValue == null)
{
return(null);
}
if (Convert.IsDBNull(dateValue))
{
return(null);
}
if ((dateValue is string) && (string.IsNullOrEmpty((string)dateValue)))
{
return(null);
}
return(DateAndTime.DatePart(interval, Convert.ToDateTime(dateValue), dayOfWeek, weekOfYear));
}
public MyAppointmentRecurrenceForm(Appointment pattern,
FirstDayOfWeek firstDayOfWeek, AppointmentFormControllerBase controller,
RecurrenceType type) : base(pattern, firstDayOfWeek, controller)
{
base.dailyRecurrenceControl1.Enabled = false;
base.weeklyRecurrenceControl1.Enabled = false;
base.monthlyRecurrenceControl1.Enabled = false;
base.yearlyRecurrenceControl1.Enabled = false;
switch (type)
{
case RecurrenceType.Daily:
base.dailyRecurrenceControl1.Enabled = true;
break;
// Code for other RecurrenceType cases if required.
}
base.grpRecurrencePattern.Text =
"You can edit only daily recurring appointments";
base.Text = "Appointment Recurrence: Modified Form";
}
public static long DateDiff(DateInterval Interval, DateTime Date1, DateTime Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
Calendar currentCalendar;
TimeSpan span = Date2.Subtract(Date1);
switch (Interval)
{
case DateInterval.Year:
currentCalendar = CurrentCalendar;
return (long) (currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1));
case DateInterval.Quarter:
currentCalendar = CurrentCalendar;
return (long) ((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 4) + ((currentCalendar.GetMonth(Date2) - 1) / 3)) - ((currentCalendar.GetMonth(Date1) - 1) / 3));
case DateInterval.Month:
currentCalendar = CurrentCalendar;
return (long) ((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 12) + currentCalendar.GetMonth(Date2)) - currentCalendar.GetMonth(Date1));
case DateInterval.DayOfYear:
case DateInterval.Day:
return (long) Math.Round(Conversion.Fix(span.TotalDays));
case DateInterval.WeekOfYear:
Date1 = Date1.AddDays((double) (0 - GetDayOfWeek(Date1, DayOfWeek)));
Date2 = Date2.AddDays((double) (0 - GetDayOfWeek(Date2, DayOfWeek)));
return (((long) Math.Round(Conversion.Fix(Date2.Subtract(Date1).TotalDays))) / 7L);
case DateInterval.Weekday:
return (((long) Math.Round(Conversion.Fix(span.TotalDays))) / 7L);
case DateInterval.Hour:
return (long) Math.Round(Conversion.Fix(span.TotalHours));
case DateInterval.Minute:
return (long) Math.Round(Conversion.Fix(span.TotalMinutes));
case DateInterval.Second:
return (long) Math.Round(Conversion.Fix(span.TotalSeconds));
}
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = 1, FirstWeekOfYear FirstWeekOfYearValue = 1)
{
DayOfWeek firstDayOfWeek;
CalendarWeekRule calendarWeekRule;
switch (Interval)
{
case DateInterval.Year:
return CurrentCalendar.GetYear(DateValue);
case DateInterval.Quarter:
return (((DateValue.Month - 1) / 3) + 1);
case DateInterval.Month:
return CurrentCalendar.GetMonth(DateValue);
case DateInterval.DayOfYear:
return CurrentCalendar.GetDayOfYear(DateValue);
case DateInterval.Day:
return CurrentCalendar.GetDayOfMonth(DateValue);
case DateInterval.WeekOfYear:
if (FirstDayOfWeekValue != FirstDayOfWeek.System)
{
firstDayOfWeek = (DayOfWeek) (FirstDayOfWeekValue - 1);
break;
}
firstDayOfWeek = Utils.GetCultureInfo().DateTimeFormat.FirstDayOfWeek;
break;
case DateInterval.Weekday:
return Weekday(DateValue, FirstDayOfWeekValue);
case DateInterval.Hour:
return CurrentCalendar.GetHour(DateValue);
case DateInterval.Minute:
return CurrentCalendar.GetMinute(DateValue);
case DateInterval.Second:
return CurrentCalendar.GetSecond(DateValue);
default:
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
switch (FirstWeekOfYearValue)
{
case FirstWeekOfYear.System:
calendarWeekRule = Utils.GetCultureInfo().DateTimeFormat.CalendarWeekRule;
break;
case FirstWeekOfYear.Jan1:
calendarWeekRule = CalendarWeekRule.FirstDay;
break;
case FirstWeekOfYear.FirstFourDays:
calendarWeekRule = CalendarWeekRule.FirstFourDayWeek;
break;
case FirstWeekOfYear.FirstFullWeek:
calendarWeekRule = CalendarWeekRule.FirstFullWeek;
break;
}
return CurrentCalendar.GetWeekOfYear(DateValue, calendarWeekRule, firstDayOfWeek);
}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}
public static int DatePart(DateInterval Interval, System.DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue, FirstWeekOfYear FirstWeekOfYearValue) {}
/// <summary>
/// Works like Visual Basic WeekDayname method.
/// </summary>
/// <param name="day">Day of the week.</param>
/// <param name="abbreviate">A value that determines whether to abbreviate the output or not.</param>
/// <param name="firstdayofweek">A value to determines to what day the week should start.</param>
/// <returns>Week day name</returns>
public static string WeekDayName(int day, bool abbreviate, FirstDayOfWeek firstdayofweek)
{
string[] _days = { "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"};
if (day <= _days.Length &&
day > 0)
{
int _selectedday = day + (int)firstdayofweek;
if (_selectedday >= (_days.Length))
{
int _over = _selectedday - _days.Length;
_selectedday = _over;
}
string _day = _days[_selectedday];
if (abbreviate) return _day.Substring(0, 3);
else return _day;
}
else throw new ArgumentException("Day should be between 1 to 7 only.");
}
public static long DateDiff(DateInterval Interval, System.DateTime Date1, System.DateTime Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}
public static string WeekdayName(int Weekday, bool Abbreviate = false, FirstDayOfWeek FirstDayOfWeekValue = 0)
{
string abbreviatedDayName;
if ((Weekday < 1) || (Weekday > 7))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
if ((FirstDayOfWeekValue < FirstDayOfWeek.System) || (FirstDayOfWeekValue > FirstDayOfWeek.Saturday))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "FirstDayOfWeekValue" }));
}
DateTimeFormatInfo format = (DateTimeFormatInfo) Utils.GetCultureInfo().GetFormat(typeof(DateTimeFormatInfo));
if (FirstDayOfWeekValue == FirstDayOfWeek.System)
{
FirstDayOfWeekValue = (FirstDayOfWeek) (format.FirstDayOfWeek + 1);
}
try
{
if (Abbreviate)
{
abbreviatedDayName = format.GetAbbreviatedDayName((DayOfWeek) (((Weekday + FirstDayOfWeekValue) - 2) % 7));
}
else
{
abbreviatedDayName = format.GetDayName((DayOfWeek) (((Weekday + FirstDayOfWeekValue) - 2) % 7));
}
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
if (abbreviatedDayName.Length == 0)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Weekday" }));
}
return abbreviatedDayName;
}
public static int Weekday(DateTime DateValue, FirstDayOfWeek DayOfWeek = 1)
{
if (DayOfWeek == FirstDayOfWeek.System)
{
DayOfWeek = (FirstDayOfWeek) (DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek + 1);
}
else if ((DayOfWeek < FirstDayOfWeek.Sunday) || (DayOfWeek > FirstDayOfWeek.Saturday))
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "DayOfWeek" }));
}
int num = ((int) CurrentCalendar.GetDayOfWeek(DateValue)) + 1;
return ((((num - DayOfWeek) + 7) % 7) + 1);
}
private static int GetDayOfWeek(DateTime dt, FirstDayOfWeek weekdayFirst)
{
if ((weekdayFirst < FirstDayOfWeek.System) || (weekdayFirst > FirstDayOfWeek.Saturday))
{
throw ExceptionUtils.VbMakeException(5);
}
if (weekdayFirst == FirstDayOfWeek.System)
{
weekdayFirst = (FirstDayOfWeek) (Utils.GetDateTimeFormatInfo().FirstDayOfWeek + 1);
}
return (((int) (((dt.DayOfWeek - ((DayOfWeek) ((int) weekdayFirst))) + 8) % (DayOfWeek.Saturday | DayOfWeek.Monday))) + 1);
}
public static string WeekdayName(int Weekday, bool Abbreviate, FirstDayOfWeek FirstDayOfWeekValue) {}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
DateTime time2;
try
{
time = Conversions.ToDate(Date1);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date1" }));
}
try
{
time2 = Conversions.ToDate(Date2);
}
catch (StackOverflowException exception4)
{
throw exception4;
}
catch (OutOfMemoryException exception5)
{
throw exception5;
}
catch (ThreadAbortException exception6)
{
throw exception6;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date2" }));
}
return DateDiff(DateIntervalFromString(Interval), time, time2, DayOfWeek, WeekOfYear);
}
public static int Weekday(System.DateTime DateValue, FirstDayOfWeek DayOfWeek) {}
protected internal virtual System.Windows.Forms.Form CreateAppointmentRecurrenceForm(DevExpress.XtraScheduler.Appointment patternCopy, FirstDayOfWeek firstDayOfWeek)
{
AppointmentRecurrenceForm form = new AppointmentRecurrenceForm(patternCopy, firstDayOfWeek, Controller);
form.LookAndFeel.ParentLookAndFeel = LookAndFeel;
form.ShowExceptionsRemoveMsgBox = controller.AreExceptionsPresent();
return form;
}
public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}