Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

PersianCalendar, classe

Représente le calendrier persan.

System.Object
  System.Globalization.Calendar
    System.Globalization.PersianCalendar

Espace de noms :  System.Globalization
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
public class PersianCalendar : Calendar

Le type PersianCalendar expose les membres suivants.

  NomDescription
Méthode publiquePersianCalendarInitialise une nouvelle instance de la classe PersianCalendar.
Début

  NomDescription
Propriété publiqueAlgorithmTypeObtient une valeur qui indique si le calendrier actuel est solaire, lunaire, ou luni-solaire. (Substitue Calendar.AlgorithmType.)
Propriété protégéeDaysInYearBeforeMinSupportedYearObtient le nombre de jours dans l'année qui précède l'année spécifiée par la propriété MinSupportedDateTime . (Hérité de Calendar.)
Propriété publiqueErasObtient la liste des ères dans un objet PersianCalendar. (Substitue Calendar.Eras.)
Propriété publiqueIsReadOnlyObtient une valeur qui indique si cet objet Calendar est en lecture seule. (Hérité de Calendar.)
Propriété publiqueMaxSupportedDateTimeObtient les dernières date et heure prises en charge par la classe PersianCalendar. (Substitue Calendar.MaxSupportedDateTime.)
Propriété publiqueMinSupportedDateTimeObtient les premières date et heure prises en charge par la classe PersianCalendar. (Substitue Calendar.MinSupportedDateTime.)
Propriété publiqueTwoDigitYearMaxObtient ou définit la dernière année d'une plage de 100 ans pouvant être représentée par une année à 2 chiffres. (Substitue Calendar.TwoDigitYearMax.)
Début

  NomDescription
Méthode publiqueAddDaysRetourne un DateTime qui est le nombre de jours spécifié jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddHoursRetourne un DateTime qui représente le nombre d'heures jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddMillisecondsRetourne un DateTime qui correspond au nombre de millisecondes spécifié jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddMinutesRetourne un DateTime qui correspond au nombre de minutes jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddMonthsRetourne un objet DateTime qui correspond au décalage du nombre de mois spécifié par rapport à l'objet DateTime spécifié. (Substitue Calendar.AddMonths(DateTime, Int32).)
Méthode publiqueAddSecondsRetourne un DateTime qui correspond au nombre de secondes spécifié jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddWeeksRetourne un DateTime qui correspond au nombre de semaines spécifié jusqu'au DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueAddYearsRetourne un objet DateTime qui est offset le nombre spécifié d'années par rapport à l'objet DateTime spécifié. (Substitue Calendar.AddYears(DateTime, Int32).)
Méthode publiqueCloneCrée un nouvel objet qui est une copie de l'objet Calendar en cours. (Hérité de Calendar.)
Méthode publiqueEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode protégéeFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiqueGetDayOfMonthRetourne le jour du mois dans l'objet DateTime spécifié. (Substitue Calendar.GetDayOfMonth(DateTime).)
Méthode publiqueGetDayOfWeekRetourne le jour de la semaine dans l'objet DateTime spécifié. (Substitue Calendar.GetDayOfWeek(DateTime).)
Méthode publiqueGetDayOfYearRetourne le jour de l'année dans l'objet DateTime spécifié. (Substitue Calendar.GetDayOfYear(DateTime).)
Méthode publiqueGetDaysInMonth(Int32, Int32)Retourne le nombre de jours dans le mois et l'année spécifiés de l'ère actuelle. (Hérité de Calendar.)
Méthode publiqueGetDaysInMonth(Int32, Int32, Int32)Retourne le nombre de jours dans le mois spécifié de l'année et de l'ère spécifiées. (Substitue Calendar.GetDaysInMonth(Int32, Int32, Int32).)
Méthode publiqueGetDaysInYear(Int32)Retourne le nombre de jours de l'année spécifiée de l'ère actuelle. (Hérité de Calendar.)
Méthode publiqueGetDaysInYear(Int32, Int32)Retourne le nombre de jours dans l'année spécifiée de l'ère spécifiée. (Substitue Calendar.GetDaysInYear(Int32, Int32).)
Méthode publiqueGetEraRetourne l'ère de l'objet DateTime spécifié. (Substitue Calendar.GetEra(DateTime).)
Méthode publiqueGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiqueGetHourRetourne l'heure du DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueGetLeapMonth(Int32)Calcule le mois d'une année bissextile d'une spécifiée. (Hérité de Calendar.)
Méthode publiqueGetLeapMonth(Int32, Int32)Retourne le mois d'une année bissextile d'une année et d'une ère spécifiées. (Substitue Calendar.GetLeapMonth(Int32, Int32).)
Méthode publiqueGetMillisecondsRetourne la valeur en millisecondes du DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueGetMinuteRetourne les minutes du DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueGetMonthRetourne le mois de l'objet DateTime spécifié. (Substitue Calendar.GetMonth(DateTime).)
Méthode publiqueGetMonthsInYear(Int32)Retourne le nombre de mois de l'année spécifiée dans l'ère actuelle. (Hérité de Calendar.)
Méthode publiqueGetMonthsInYear(Int32, Int32)Retourne le nombre de mois dans l'année spécifiée de l'ère spécifiée. (Substitue Calendar.GetMonthsInYear(Int32, Int32).)
Méthode publiqueGetSecondRetourne les secondes du DateTime spécifié. (Hérité de Calendar.)
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueGetWeekOfYearRetourne la semaine de l'année qui contient la date de la valeur DateTime spécifiée. (Hérité de Calendar.)
Méthode publiqueGetYearRetourne l'année dans l'objet DateTime spécifié. (Substitue Calendar.GetYear(DateTime).)
Méthode publiqueIsLeapDay(Int32, Int32, Int32)Détermine si la date spécifiée dans l'ère en cours est une année bissextile. (Hérité de Calendar.)
Méthode publiqueIsLeapDay(Int32, Int32, Int32, Int32)Détermine si la date spécifiée est un jour bissextile. (Substitue Calendar.IsLeapDay(Int32, Int32, Int32, Int32).)
Méthode publiqueIsLeapMonth(Int32, Int32)Détermine si le mois spécifié de l'année spécifiée dans l'ère en cours est un mois bissextile. (Hérité de Calendar.)
Méthode publiqueIsLeapMonth(Int32, Int32, Int32)Détermine si le mois spécifié de l'année et de l'ère spécifiées est un mois d'une année bissextile. (Substitue Calendar.IsLeapMonth(Int32, Int32, Int32).)
Méthode publiqueIsLeapYear(Int32)Détermine si l'année spécifiée dans l'ère en cours est une année bissextile. (Hérité de Calendar.)
Méthode publiqueIsLeapYear(Int32, Int32)Détermine si l'année spécifiée de l'ère spécifiée est une année bissextile. (Substitue Calendar.IsLeapYear(Int32, Int32).)
Méthode protégéeMemberwiseCloneCrée une copie superficielle de l'objet Object actuel. (Hérité de Object.)
Méthode publiqueToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)Retourne un DateTime correspondant à la date et à l'heure spécifiées pour l'ère en cours. (Hérité de Calendar.)
Méthode publiqueToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)Retourne un objet DateTime auquel sont affectées la date, l'heure et l'ère spécifiées. (Substitue Calendar.ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32).)
Méthode publiqueToFourDigitYearConvertit l'année spécifiée en une représentation sur quatre chiffres de l'année. (Substitue Calendar.ToFourDigitYear(Int32).)
Méthode publiqueToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

  NomDescription
Champ publicMembre statiquePersianEraReprésente l'ère en cours. Ce champ est constant.
Début

Le calendrier persan est utilisé dans la plupart des pays où le Perse est parlé, bien que certaines régions utilisent des noms de mois différents. Le calendrier persan est le calendrier officiel de l'Iran et de l'Afghanistan et c'est l'un des calendriers différents utilisés dans les régions telles que le Kazakhstan et le Tadjikistan.

RemarqueRemarque

Pour plus d'informations sur l'utilisation de la classe PersianCalendar et pour les autres classes de calendrier dans le .NET Framework, consultez Utilisation des calendriers.

Les dates dans le calendrier persan démarrent à l'année du Hijra, qui correspond à 622 C.E. et l'année où Muhammad (PBUH) a migré de Mecque à la Médina. Par exemple, la date du 21 mars 2002 C.E. correspond au premier jour du mois de Farvardeen dans l'année persane 1381.

Le calendrier perse est basé sur une année solaire et compte approximativement 365 jours. Une année s'étale sur quatre saisons, et une nouvelle année commence lorsque le soleil traverse l'équateur de l'hémisphère sud vers l'hémisphère nord par rapport au centre de la Terre. La nouvelle année marque le premier jour du mois de Farvardeen qui est le premier jour du printemps dans l'hémisphère nord.

Chacun des six premiers mois du calendrier persan contient 31 jours, chacun des cinq mois suivants contient 30 jours, et le dernier mois contient 29 jours dans une année normale et 30 jours dans une année bissextile. Une année bissextile est une année qui, en cas de division par 33, a un reste de 1, 5, 9, 13, 17, 22, 26 ou 30. Par exemple, l'année 1370 est une année bissextile parce que sa division par 33 génère un reste de 17. Il y a approximativement huit années bissextiles dans chaque cycle de 33 années.

Utilisation du calendrier persan

Les applications utilisent un objet PersianCalendar pour calculer des dates dans le calendrier persan ou convertir des dates persanes en dates grégoriennes et vice versa.

Votre application ne doit pas utiliser d'objet PersianCalendar comme calendrier par défaut pour une culture. Le calendrier par défaut est spécifié par la propriété CultureInfo.Calendar et doit être l'un des calendriers retournés par la propriété CultureInfo.OptionalCalendars. Actuellement, la classe PersianCalendar n'est pas un calendrier facultatif pour toute culture prise en charge par la classe CultureInfo et par conséquent ne peut pas être un calendrier par défaut.

L'exemple suivant instancie des objets DateTime en utilisant la propriété DateTime.Now, d'un constructeur DateTime, et la méthode ToDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32) du calendrier persan. Il affiche ensuite ces dates dans les calendriers grégorien et persans. Il affiche également la plage de dates du calendrier persan.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
        PersianCalendar pc = new PersianCalendar();
        DateTime thisDate = DateTime.Now;

        // Display the current date using the Gregorian and Persian calendars. 
        Console.WriteLine("Today in the Gregorian Calendar:  {0:dddd}, {0}", thisDate);
        Console.WriteLine("Today in the Persian Calendar:    {0}, {1}/{2}/{3} {4}:{5}:{6}\n",  
                      pc.GetDayOfWeek(thisDate), 
                      pc.GetMonth(thisDate), 
                      pc.GetDayOfMonth(thisDate),  
                      pc.GetYear(thisDate), 
                      pc.GetHour(thisDate), 
                      pc.GetMinute(thisDate), 
                      pc.GetSecond(thisDate));

        // Create a date using the Gregorian calendar.
        thisDate = new DateTime(2013, 5, 28, 10, 35, 0);
        Console.WriteLine("Gregorian Calendar:  {0:D} ", thisDate);
        Console.WriteLine("Persian Calendar:    {0}, {1}/{2}/{3} {4}:{5}:{6}\n",  
                          pc.GetDayOfWeek(thisDate), 
                          pc.GetMonth(thisDate), 
                          pc.GetDayOfMonth(thisDate),  
                          pc.GetYear(thisDate), 
                          pc.GetHour(thisDate), 
                          pc.GetMinute(thisDate), 
                          pc.GetSecond(thisDate));

        // Create a date using the Persian calendar.
        thisDate = pc.ToDateTime(1395, 4, 22, 12, 30, 0, 0);
        Console.WriteLine("Gregorian Calendar:  {0:D} ", thisDate);
        Console.WriteLine("Persian Calendar:    {0}, {1}/{2}/{3} {4}:{5}:{6}\n",  
                      pc.GetDayOfWeek(thisDate), 
                      pc.GetMonth(thisDate), 
                      pc.GetDayOfMonth(thisDate),  
                      pc.GetYear(thisDate), 
                      pc.GetHour(thisDate), 
                      pc.GetMinute(thisDate), 
                      pc.GetSecond(thisDate));

        // Show the Persian Calendar date range.
        Console.WriteLine("Minimum Persian Calendar date (Gregorian Calendar):  {0:D} ", 
                          pc.MinSupportedDateTime);
        Console.WriteLine("Minimum Persian Calendar date (Persian Calendar):  " +    
                          "{0}, {1}/{2}/{3} {4}:{5}:{6}\n",  
                          pc.GetDayOfWeek(pc.MinSupportedDateTime), 
                          pc.GetMonth(pc.MinSupportedDateTime), 
                          pc.GetDayOfMonth(pc.MinSupportedDateTime),  
                          pc.GetYear(pc.MinSupportedDateTime), 
                          pc.GetHour(pc.MinSupportedDateTime), 
                          pc.GetMinute(pc.MinSupportedDateTime), 
                          pc.GetSecond(pc.MinSupportedDateTime));

        Console.WriteLine("Maximum Persian Calendar date (Gregorian Calendar):  {0:D} ", 
                          pc.MaxSupportedDateTime);
        Console.WriteLine("Maximum Persian Calendar date (Persian Calendar):  " +   
                          "{0}, {1}/{2}/{3} {4}:{5}:{6}\n",  
                          pc.GetDayOfWeek(pc.MaxSupportedDateTime), 
                          pc.GetMonth(pc.MaxSupportedDateTime), 
                          pc.GetDayOfMonth(pc.MaxSupportedDateTime),  
                          pc.GetYear(pc.MaxSupportedDateTime), 
                          pc.GetHour(pc.MinSupportedDateTime), 
                          pc.GetMinute(pc.MaxSupportedDateTime), 
                          pc.GetSecond(pc.MaxSupportedDateTime));
   }
}
// The example displays the following output:
//    Today in the Gregorian Calendar:  Monday, 2/4/2013 9:11:36 AM
//    Today in the Persian Calendar:    Monday, 11/16/1391 9:11:36
//    
//    Gregorian Calendar:  Tuesday, May 28, 2013
//    Persian Calendar:    Tuesday, 3/7/1392 10:35:0
//    
//    Gregorian Calendar:  Tuesday, July 12, 2016
//    Persian Calendar:    Tuesday, 4/22/1395 12:30:0
//    
//    Minimum Persian Calendar date (Gregorian Calendar):  Thursday, March 21, 0622
//    Minimum Persian Calendar date (Persian Calendar):  Thursday, 1/1/1 0:0:0
//    
//    Maximum Persian Calendar date (Gregorian Calendar):  Friday, December 31, 9999
//    Maximum Persian Calendar date (Persian Calendar):  Friday, 10/10/9378 0:59:59


L'exemple suivant illustre les membres de champ, de propriété et de méthode de la classe PersianCalendar.


using System;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
      PersianCalendar jc = new PersianCalendar();
      DateTime thisDate = DateTime.Now;

		//--------------------------------------------------------------------------------
		// Properties
		//--------------------------------------------------------------------------------
      Console.WriteLine("\n........... Selected Properties .....................\n");
      Console.Write("Eras:");
      foreach (int era in jc.Eras)
      {
         Console.WriteLine(" era = {0}", era);
      }
		//--------------------------------------------------------------------------------
      Console.WriteLine("\nTwoDigitYearMax = {0}", jc.TwoDigitYearMax);
		//--------------------------------------------------------------------------------
		// Methods
		//--------------------------------------------------------------------------------
      Console.WriteLine("\n............ Selected Methods .......................\n");

		//--------------------------------------------------------------------------------
      Console.WriteLine("GetDayOfYear: day = {0}", jc.GetDayOfYear(thisDate));
		//--------------------------------------------------------------------------------
      Console.WriteLine("GetDaysInMonth: days = {0}", 
                        jc.GetDaysInMonth( thisDate.Year, thisDate.Month, 
                        PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------
      Console.WriteLine("GetDaysInYear: days = {0}", 
                        jc.GetDaysInYear(thisDate.Year, PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------
      Console.WriteLine("GetLeapMonth: leap month (if any) = {0}", 
                        jc.GetLeapMonth(thisDate.Year, PersianCalendar.PersianEra));
		//-------------------------------------------------------------
      Console.WriteLine("GetMonthsInYear: months in a year = {0}", 
                        jc.GetMonthsInYear(thisDate.Year, PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------
      Console.WriteLine("IsLeapDay: This is a leap day = {0}", 
                        jc.IsLeapDay(thisDate.Year, thisDate.Month, thisDate.Day, 
                        PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------
      Console.WriteLine("IsLeapMonth: This is a leap month = {0}", 
                        jc.IsLeapMonth(thisDate.Year, thisDate.Month, 
                        PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------
      Console.WriteLine("IsLeapYear: 1370 is a leap year = {0}", 
                        jc.IsLeapYear(1370, PersianCalendar.PersianEra));
		//--------------------------------------------------------------------------------

		// Get the 4-digit year for a year whose last two digits are 99. The 4-digit year 
		// depends on the current value of the TwoDigitYearMax property.

      Console.WriteLine("ToFourDigitYear:");
      Console.WriteLine("  If TwoDigitYearMax = {0}, ToFourDigitYear(99) = {1}", 
                         jc.TwoDigitYearMax, jc.ToFourDigitYear(99));
      jc.TwoDigitYearMax = thisDate.Year;
      Console.WriteLine("  If TwoDigitYearMax = {0}, ToFourDigitYear(99) = {1}", 
                        jc.TwoDigitYearMax, jc.ToFourDigitYear(99));
    }
}
// The example displays the following output:
//       ........... Selected Properties .....................
//       
//       Eras: era = 1
//       
//       TwoDigitYearMax = 99
//       
//       ............ Selected Methods .......................
//       
//       GetDayOfYear: day = 1
//       GetDaysInMonth: days = 31
//       GetDaysInYear: days = 365
//       GetLeapMonth: leap month (if any) = 0
//       GetMonthsInYear: months in a year = 12
//       IsLeapDay: This is a leap day = False
//       IsLeapMonth: This is a leap month = False
//       IsLeapYear: 1370 is a leap year = True
//       ToFourDigitYear:
//         If TwoDigitYearMax = 99, ToFourDigitYear(99) = 99
//         If TwoDigitYearMax = 2012, ToFourDigitYear(99) = 1999


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft