/// <summary> /// Parse hijri date string with specific formats /// </summary> /// <param name="strDate">the date time string to parse</param> /// <returns>DateTime?</returns> public static DateTime?ParseHijriDate(this string strDate, params string[] formats) { if (string.IsNullOrWhiteSpace(strDate)) { return(null); } DateTime result; CultureInfo cul; Calendar calendar = new System.Globalization.UmAlQuraCalendar(); cul = new CultureInfo("ar-SA"); cul.DateTimeFormat.Calendar = calendar; try { if (DateTime.TryParseExact(strDate, formats, cul, DateTimeStyles.AllowWhiteSpaces, out result)) { return(result); } else { //try to parse as hijri cul.DateTimeFormat.Calendar = new HijriCalendar(); if (DateTime.TryParseExact(strDate, formats, cul, DateTimeStyles.AllowWhiteSpaces, out result)) { return(result); } } return(null); } catch { return(null); } }
public static string GregToHijri(DateTime dtTime) { if (dtTime == DateTime.MinValue) return ""; UmAlQuraCalendar calHijri = new UmAlQuraCalendar(); string weekday = Convert.ToString(calHijri.GetDayOfWeek(dtTime)); int CurrDayOfMonth = calHijri.GetDayOfMonth(dtTime); int CurrMonth = calHijri.GetMonth(dtTime); int Curryear = calHijri.GetYear(dtTime); return CurrDayOfMonth.ToString() + "/" + CurrMonth.ToString() + "/" + Curryear.ToString(); }
public static DateTime?ToHijriDateTimeObject(this string date) { if (string.IsNullOrEmpty(date.Trim())) { return(null); } string[] DateParts = date.Split('/'); var umAlQura = new System.Globalization.UmAlQuraCalendar(); return(umAlQura.ToDateTime(int.Parse(DateParts[2]), int.Parse(DateParts[1]), int.Parse(DateParts[0]), 0, 0, 0, 0)); }
public static string GregToHijriCompleteWithDay(DateTime dtTime) { if (dtTime == DateTime.MinValue) return ""; UmAlQuraCalendar calHijri = new UmAlQuraCalendar(); CultureInfo info = new CultureInfo("ar-sa"); info.DateTimeFormat.Calendar = calHijri; string weekday = Convert.ToString(calHijri.GetDayOfWeek(dtTime)); int CurrDayOfMonth = calHijri.GetDayOfMonth(dtTime); int CurrMonth = calHijri.GetMonth(dtTime); int Curryear = calHijri.GetYear(dtTime); return string.Format("{0} {3}/{2}/{1} هـ ", dtTime.ToString("dddd", info), CurrDayOfMonth.ToString(), CurrMonth.ToString(), Curryear.ToString()); }
public void CanUseDateInCalendar() { var dt = new Date(2015, 1, 1); var calendar = new UmAlQuraCalendar(); var year = calendar.GetYear(dt); var month = calendar.GetMonth(dt); var day = calendar.GetDayOfMonth(dt); Assert.Equal(1436, year); Assert.Equal(3, month); Assert.Equal(10, day); }
public static string ToHijriDate(this DateTime dateTime, string format) { CultureInfo cul = new CultureInfo("ar-SA"); Calendar calendar; try { //check with UmAlQura calendar = new System.Globalization.UmAlQuraCalendar(); if (dateTime.IsSupportedDateTime(calendar)) { calendar = new System.Globalization.HijriCalendar(); } cul.DateTimeFormat.Calendar = calendar; return(dateTime.ToString(format, cul)); } catch { return(String.Empty); } }
/// <summary>Returns a <see cref="T:System.DateTime" /> that is set to the specified date, time, and era.</summary> /// <param name="year">A year. </param> /// <param name="month">An integer from 1 through 12 that represents a month. </param> /// <param name="day">An integer from 1 through 29 that represents a day. </param> /// <param name="hour">An integer from 0 through 23 that represents an hour. </param> /// <param name="minute">An integer from 0 through 59 that represents a minute. </param> /// <param name="second">An integer from 0 through 59 that represents a second. </param> /// <param name="millisecond">An integer from 0 through 999 that represents a millisecond. </param> /// <param name="era">An era. Specify <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns>The <see cref="T:System.DateTime" /> that is set to the specified date and time in the current era.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" />, <paramref name="month" />, <paramref name="day" />, or <paramref name="era" /> is outside the range supported by the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class.-or- /// <paramref name="hour" /> is less than zero or greater than 23.-or- /// <paramref name="minute" /> is less than zero or greater than 59.-or- /// <paramref name="second" /> is less than zero or greater than 59.-or- /// <paramref name="millisecond" /> is less than zero or greater than 999. </exception> // Token: 0x06002EE9 RID: 12009 RVA: 0x000B40A4 File Offset: 0x000B22A4 public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { if (day >= 1 && day <= 29) { UmAlQuraCalendar.CheckYearMonthRange(year, month, era); } else { int daysInMonth = this.GetDaysInMonth(year, month, era); if (day < 1 || day > daysInMonth) { throw new ArgumentOutOfRangeException("day", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Day"), daysInMonth, month)); } } long absoluteDateUmAlQura = UmAlQuraCalendar.GetAbsoluteDateUmAlQura(year, month, day); if (absoluteDateUmAlQura >= 0L) { return(new DateTime(absoluteDateUmAlQura * 864000000000L + Calendar.TimeToTicks(hour, minute, second, millisecond))); } throw new ArgumentOutOfRangeException(null, Environment.GetResourceString("ArgumentOutOfRange_BadYearMonthDay")); }
public static string ToHijriDateWithFormat(this DateTime dateTime, string format) { string result = String.Empty; CultureInfo arCul = new CultureInfo("ar-SA"); Calendar calendar; try { //check UmAlQura boundaries calendar = new System.Globalization.UmAlQuraCalendar(); if (dateTime < calendar.MinSupportedDateTime || dateTime > calendar.MaxSupportedDateTime) { calendar = new System.Globalization.HijriCalendar(); } arCul.DateTimeFormat.Calendar = calendar; result = dateTime.ToString(format, arCul); } catch { result = String.Empty; } return(result); }
public static string GregToHijriTime(DateTime dtTime) { if (dtTime == DateTime.MinValue) return ""; UmAlQuraCalendar calHijri = new UmAlQuraCalendar(); CultureInfo info = new CultureInfo("ar-sa"); info.DateTimeFormat.Calendar = calHijri; string weekday = Convert.ToString(calHijri.GetDayOfWeek(dtTime)); int CurrDayOfMonth = calHijri.GetDayOfMonth(dtTime); int CurrMonth = calHijri.GetMonth(dtTime); int Curryear = calHijri.GetYear(dtTime); return dtTime.ToString("hh:mm tt", info); }
public static Calendar CalendarFromString( string name ) { Calendar c; if (name == null) { name = String.Empty; } switch (name.ToLower()) { case "hebrew": c = new HebrewCalendar(); break; case "hijri": c = new HijriCalendar(); break; case "japanese": c = new JapaneseCalendar(); break; case "korean": c = new KoreanCalendar(); break; case "taiwan": c = new TaiwanCalendar(); break; case "thaibuddhist": c = new ThaiBuddhistCalendar(); break; case "umalqura": c = new UmAlQuraCalendar(); break; #if !SILVERLIGHT case "persian": c = new PersianCalendar(); break; #endif default: c = new GregorianCalendar(); break; } return c; }
/// <summary>Determines whether the specified year in the specified era is a leap year.</summary> /// <param name="year">A year. </param> /// <param name="era">An era. Specify <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns> /// <see langword="true" /> if the specified year is a leap year; otherwise, <see langword="false" />.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" /> or <paramref name="era" /> is outside the range supported by the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class. </exception> // Token: 0x06002EE8 RID: 12008 RVA: 0x000B4089 File Offset: 0x000B2289 public override bool IsLeapYear(int year, int era) { UmAlQuraCalendar.CheckYearRange(year, era); return(UmAlQuraCalendar.RealGetDaysInYear(year) == 355); }
/// <summary>Determines whether the specified month in the specified year and era is a leap month.</summary> /// <param name="year">A year. </param> /// <param name="month">An integer from 1 through 12 that represents a month. </param> /// <param name="era">An era. Specify <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns>Always <see langword="false" /> because the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class does not support leap months.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" />, <paramref name="month" />, or <paramref name="era" /> is outside the range supported by the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class. </exception> // Token: 0x06002EE7 RID: 12007 RVA: 0x000B407E File Offset: 0x000B227E public override bool IsLeapMonth(int year, int month, int era) { UmAlQuraCalendar.CheckYearMonthRange(year, month, era); return(false); }
/// <summary>Calculates the leap month for a specified year and era.</summary> /// <param name="year">A year.</param> /// <param name="era">An era. Specify <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns>Always 0 because the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class does not support leap months.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" /> is less than 1318 or greater than 1450.-or- /// <paramref name="era" /> is not <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</exception> // Token: 0x06002EE6 RID: 12006 RVA: 0x000B4074 File Offset: 0x000B2274 public override int GetLeapMonth(int year, int era) { UmAlQuraCalendar.CheckYearRange(year, era); return(0); }
/// <summary>Calculates the number of months in the specified year of the specified era.</summary> /// <param name="year">A year. </param> /// <param name="era">An era. Specify <see langword="UmAlQuaraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns>Always 12.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" /> is outside the range supported by this calendar. </exception> /// <exception cref="T:System.ArgumentException"> /// <paramref name="era" /> is outside the range supported by this calendar. </exception> // Token: 0x06002EE3 RID: 12003 RVA: 0x000B3FFD File Offset: 0x000B21FD public override int GetMonthsInYear(int year, int era) { UmAlQuraCalendar.CheckYearRange(year, era); return(12); }
/// <summary>Calculates the era in which a specified date occurs.</summary> /// <param name="time">The date value to read. </param> /// <returns>Always returns the <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" /> value.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="time" /> is outside the range supported by this calendar. </exception> // Token: 0x06002EE0 RID: 12000 RVA: 0x000B3FD8 File Offset: 0x000B21D8 public override int GetEra(DateTime time) { UmAlQuraCalendar.CheckTicksRange(time.Ticks); return(1); }
/// <summary>Calculates the number of days in the specified year of the specified era.</summary> /// <param name="year">A year. </param> /// <param name="era">An era. Specify <see langword="UmAlQuraCalendar.Eras[UmAlQuraCalendar.CurrentEra]" /> or <see cref="F:System.Globalization.UmAlQuraCalendar.UmAlQuraEra" />.</param> /// <returns>The number of days in the specified year and era. The number of days is 354 in a common year or 355 in a leap year.</returns> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="year" /> or <paramref name="era" /> is outside the range supported by the <see cref="T:System.Globalization.UmAlQuraCalendar" /> class. </exception> // Token: 0x06002EDF RID: 11999 RVA: 0x000B3FC9 File Offset: 0x000B21C9 public override int GetDaysInYear(int year, int era) { UmAlQuraCalendar.CheckYearRange(year, era); return(UmAlQuraCalendar.RealGetDaysInYear(year)); }
static UmAlQuraYearMonthDayCalculator() { // Try to initialize. If anything fails, YearLengths will still be null, so IsSupported will return false. Calendar bclCalendar; #if PCL // Can't refer to the BCL calendar by name, but it *might* be available anyway. Let's try to instantiate // it with reflection. If we can't, that's fair enough. try { var type = typeof(Calendar).Assembly.GetType("System.Globalization.UmAlQuraCalendar"); if (type == null) { return; } bclCalendar = (Calendar) Activator.CreateInstance(type); } catch { // Don't really care what went wrong here. We'll assume it's not supported. return; } #else bclCalendar = new UmAlQuraCalendar(); #endif DateTime minDateTime = bclCalendar.MinSupportedDateTime; // Check if this looks like a sensible implementation, with a limited time range. // (The .NET implementation only runs from 1900-2077, for example.) // Mono is unfortunately broken - it advertises a large range, but then is inconsistent: // Year 2 (for example) either has 354 or 355 days depending on how you ask. if (minDateTime.Year < 1800 || minDateTime.Year > 3000) { YearLengths = null; MonthLengths = null; YearStartDays = null; return; } // Work out the min and max supported years, ensuring that we support complete years. ComputedMinYear = bclCalendar.GetYear(minDateTime); if (bclCalendar.GetMonth(minDateTime) != 1 || bclCalendar.GetDayOfMonth(minDateTime) != 1) { ComputedMinYear++; } DateTime maxDateTime = bclCalendar.MaxSupportedDateTime; ComputedMaxYear = bclCalendar.GetYear(maxDateTime); if (bclCalendar.GetMonth(maxDateTime) != 12 || bclCalendar.GetDayOfMonth(maxDateTime) != bclCalendar.GetDaysInMonth(ComputedMaxYear, 12)) { ComputedMaxYear--; } // For year lengths, we need to handle 1 year beyond the boundaries, too. // We don't need MonthLengths to be quite as long, but it's simpler to be consistent. YearLengths = new int[ComputedMaxYear - ComputedMinYear + 3]; YearStartDays = new int[ComputedMaxYear - ComputedMinYear + 3]; MonthLengths = new int[ComputedMaxYear - ComputedMinYear + 3]; int totalDays = 0; for (int year = ComputedMinYear; year <= ComputedMaxYear; year++) { int yearIndex = year - ComputedMinYear + 1; YearLengths[yearIndex] = bclCalendar.GetDaysInYear(year); YearStartDays[yearIndex] = totalDays; totalDays += YearLengths[yearIndex]; int monthBits = 0; for (int month = 1; month <= 12; month++) { if (bclCalendar.GetDaysInMonth(year, month) == 30) { monthBits |= 1 << month; } } MonthLengths[yearIndex] = monthBits; } // Fill in the cache with dummy data for before/after the min/max year, pretending // that both of the "extra" years were 354 days long. YearStartDays[0] = -354; YearStartDays[YearStartDays.Length - 1] = totalDays; YearLengths[0] = 354; YearLengths[YearStartDays.Length - 1] = 354; // Assume every 10 years before minDateTime has exactly 3544 days... it doesn't matter whether or not that's // correct, but it gets roughly the right estimate. It doesn't matter that startOfMinYear isn't in UTC; we're only // taking the Ticks property, which doesn't take account of the Kind. DateTime startOfMinYear = bclCalendar.ToDateTime(ComputedMinYear, 1, 1, 0, 0, 0, 0); ComputedDaysAtStartOfMinYear = (int) ((startOfMinYear.Ticks - NodaConstants.BclTicksAtUnixEpoch) / NodaConstants.TicksPerDay); ComputedDaysAtStartOfYear1 = ComputedDaysAtStartOfMinYear + (int) (((1 - ComputedMinYear) / 10.0) * AverageDaysPer10Years); }
// Token: 0x06002ED7 RID: 11991 RVA: 0x000B3DB8 File Offset: 0x000B1FB8 internal virtual int GetDatePart(DateTime time, int part) { int num = 0; int num2 = 0; int num3 = 0; long ticks = time.Ticks; UmAlQuraCalendar.CheckTicksRange(ticks); UmAlQuraCalendar.ConvertGregorianToHijri(time, ref num, ref num2, ref num3); if (part == 0) { return(num); } if (part == 2) { return(num2); } if (part == 3) { return(num3); } if (part == 1) { return((int)(UmAlQuraCalendar.GetAbsoluteDateUmAlQura(num, num2, num3) - UmAlQuraCalendar.GetAbsoluteDateUmAlQura(num, 1, 1) + 1L)); } throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_DateTimeParsing")); }
public static void UmAlQuraTest() { UmAlQuraCalendar cal2 = new UmAlQuraCalendar(); Assert.False(cal2.IsLeapMonth(1400, 10)); }
private static void Include(UmAlQuraCalendar sb) { sb = new System.Globalization.UmAlQuraCalendar(); }
public void GenerateData() { var bclCalendar = new UmAlQuraCalendar(); DateTime minDateTime = bclCalendar.MinSupportedDateTime; // Work out the min and max supported years, ensuring that we support complete years. var minYear = bclCalendar.GetYear(minDateTime); if (bclCalendar.GetMonth(minDateTime) != 1 || bclCalendar.GetDayOfMonth(minDateTime) != 1) { minYear++; } DateTime maxDateTime = bclCalendar.MaxSupportedDateTime; var maxYear = bclCalendar.GetYear(maxDateTime); if (bclCalendar.GetMonth(maxDateTime) != 12 || bclCalendar.GetDayOfMonth(maxDateTime) != bclCalendar.GetDaysInMonth(maxYear, 12)) { maxYear--; } // This is two elements longer than it needs to be, but it's simpler this way. var monthLengths = new ushort[maxYear - minYear + 3]; for (int year = minYear; year <= maxYear; year++) { int yearIndex = year - minYear + 1; ushort monthBits = 0; for (int month = 1; month <= 12; month++) { if (bclCalendar.GetDaysInMonth(year, month) == 30) { monthBits |= (ushort) (1 << month); } } monthLengths[yearIndex] = monthBits; } byte[] data = monthLengths.SelectMany(value => new[] { (byte)(value >> 8), (byte)(value & 0xff) }).ToArray(); // Assume every 10 years before minDateTime has exactly 3544 days... it doesn't matter whether or not that's // correct, but it gets roughly the right estimate. It doesn't matter that startOfMinYear isn't in UTC; we're only // taking the Ticks property, which doesn't take account of the Kind. DateTime startOfMinYear = bclCalendar.ToDateTime(minYear, 1, 1, 0, 0, 0, 0); var computedDaysAtStartOfMinYear = (int)((startOfMinYear.Ticks - NodaConstants.BclTicksAtUnixEpoch) / NodaConstants.TicksPerDay); Console.WriteLine($"private const int ComputedMinYear = {minYear};"); Console.WriteLine($"private const int ComputedMaxYear = {maxYear};"); Console.WriteLine($"private const int ComputedDaysAtStartOfMinYear = {computedDaysAtStartOfMinYear};"); Console.WriteLine("private const string GeneratedData ="); // Adapted from PersianCalendarSystemTest. If we do this any more, we should // put it somewhere common. var base64 = Convert.ToBase64String(data); var lineLength = 80; for (int start = 0; start < base64.Length; start += lineLength) { var line = base64.Substring(start, Math.Min(lineLength, base64.Length - start)); var last = start + lineLength >= base64.Length; Console.WriteLine($" \"{line}\"{(last ? ";" : " +")}"); } Console.WriteLine(); }
public DateTimeFormatter(string dateTimePattern, string calendarName, string amDesignator, string pmDesignator) { Calendar calendar = null; switch (calendarName) { case "ChineseLunisolarCalendar": calendar = new ChineseLunisolarCalendar(); break; case "GregorianCalendar": calendar = new GregorianCalendar(); break; case "HebrewCalendar": calendar = new HebrewCalendar(); break; case "HijriCalendar": calendar = new HijriCalendar(); break; case "JapaneseCalendar": calendar = new JapaneseCalendar(); break; case "JapaneseLunisolarCalendar": calendar = new JapaneseLunisolarCalendar(); break; case "JulianCalendar": calendar = new JulianCalendar(); break; case "KoreanCalendar": calendar = new KoreanCalendar(); break; case "KoreanLunisolarCalendar": calendar = new KoreanLunisolarCalendar(); break; case "PersianCalendar": calendar = new PersianCalendar(); break; case "TaiwanCalendar": calendar = new TaiwanCalendar(); break; case "TaiwanLunisolarCalendar": calendar = new TaiwanLunisolarCalendar(); break; case "ThaiBuddhistCalendar": calendar = new ThaiBuddhistCalendar(); break; case "UmAlQuraCalendar": calendar = new UmAlQuraCalendar(); break; } Initialize(dateTimePattern, calendar, amDesignator, pmDesignator); }