Le Tutoriel de C# Date Time

View more categories:

1- Les Classes liées Date, Heure dans C#

Dans . NET Framework, System.DateTime est une classe qui représente les dates et les heures. Sa valeur est comprise 12:00:00 à 11:59:59 01-01-0001 nuit de 31-12 jours -9999.
à vous il y a beaucoup de méthodes d'initialisation (constructeur) initialiser un objet  DateTime.
DateTime Constructors
public DateTime(int year, int month, int day)

public DateTime(int year, int month, int day, Calendar calendar)

public DateTime(int year, int month, int day, int hour, int minute, int second)

public DateTime(int year, int month, int day, int hour, int minute, int second, Calendar calendar)

public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind)

public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)

public DateTime(int year, int month, int day, int hour,
                    int minute, int second, int millisecond, Calendar calendar)

public DateTime(int year, int month, int day, int hour,
                   int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind)

public DateTime(int year, int month, int day, int hour,
                    int minute, int second, int millisecond, DateTimeKind kind)

public DateTime(long ticks)

public DateTime(long ticks, DateTimeKind kind)
  • TODO - EXAMPLE
Now (maintenant c'est une propriété statique de  DateTime , il retourne l'objet  DateTime décrivez l'heure de la date actuelle.
// L'objet décrit l'heure actuelle.
DateTime now = DateTime.Now;

Console.WriteLine("Now is "+ now);

2- Attributs DateTime  

Property Data Type Description
Date DateTime

Gets the date component of this instance.

Day int

Gets the day of the month represented by this instance.

DayOfWeek DayOfWeek

Gets the day of the week represented by this instance.

DayOfYear int

Gets the day of the year represented by this instance.

Hour int

Gets the hour component of the date represented by this instance.

Kind DateTimeKind

Gets a value that indicates whether the time represented by this instance is based on local time, Coordinated Universal Time (UTC), or neither.

Millisecond int

Gets the milliseconds component of the date represented by this instance.

Minute int

Gets the minute component of the date represented by this instance.

Month int

Gets the month component of the date represented by this instance.

Now DateTime

Gets a DateTime object that is set to the current date and time on this computer, expressed as the local time.

Second int

Gets the seconds component of the date represented by this instance.

Ticks long

Gets the number of ticks that represent the date and time of this instance.
(1 Minute = 600 million ticks).

TimeOfDay TimeSpan

Gets the time of day for this instance.

Today DateTime

Gets the current date.

UtcNow DateTime

Gets a DateTime object that is set to the current date and time on this computer, expressed as the Coordinated Universal Time (UTC).

Year int

Gets the year component of the date represented by this instance.

DateTimePropertiesExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class DateTimePropertiesExample
    {

        public static void Main(string[] args)
        {
            // Créez un objet DateTime (année, mois, jour, heure, minutes, secondes).
            DateTime aDateTime = new DateTime(2005, 11, 20, 12, 1, 10); 

            // Imprimer les informations:
            Console.WriteLine("Day:{0}", aDateTime.Day);
            Console.WriteLine("Month:{0}", aDateTime.Month);
            Console.WriteLine("Year:{0}", aDateTime.Year);
            Console.WriteLine("Hour:{0}", aDateTime.Hour);
            Console.WriteLine("Minute:{0}", aDateTime.Minute);
            Console.WriteLine("Second:{0}", aDateTime.Second);
            Console.WriteLine("Millisecond:{0}", aDateTime.Millisecond);

            // Enum {Monday, Tuesday,... Sunday}
            DayOfWeek dayOfWeek = aDateTime.DayOfWeek;   


            Console.WriteLine("Day of Week:{0}", dayOfWeek ); 
           

            Console.WriteLine("Day of Year: {0}", aDateTime.DayOfYear);

            // Un objet décrit seulement l'heure (heure minute, ...)
            // ​​​​​​​
            TimeSpan timeOfDay = aDateTime.TimeOfDay; 

            Console.WriteLine("Time of Day:{0}", timeOfDay);

            // Convertir en tiques (1 seconde = 10 000 000 tiques)
            Console.WriteLine("Tick:{0}", aDateTime.Ticks);

            // {Local, Itc, Unspecified}
            DateTimeKind kind = aDateTime.Kind; 

            Console.WriteLine("Kind:{0}", kind);

            Console.Read();
        }
    }

}
Exécutez l'exemple:
 

3- Ajouter et soustraire DateTime

Datetime fournit des méthodes qui vous permettent d'ajouter ou de soustraire une période de temps. Timespan est une classe qui contient des informations d'une période de temps, il peut participer en tant que paramètre dans la méthode d'addition ou de soustraction du temps de DateTime.
Exemple:
AddSubtractExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class AddSubtractExample
    {

        public static void Main(string[] args)
        {
            // Current Time
            DateTime aDateTime = DateTime.Now;

            Console.WriteLine("Now is " + aDateTime);

            // An Interval.
            // 1 hour + 1 minute
            TimeSpan aInterval = new System.TimeSpan(0, 1, 1, 0);

            // Add an interval.
            DateTime newTime = aDateTime.Add(aInterval);


            Console.WriteLine("After add 1 hour, 1 minute: " + newTime);

            // Subtract an interval.
            newTime = aDateTime.Subtract(aInterval);

            Console.WriteLine("After subtract 1 hour, 1 minute: " + newTime);

            Console.Read();
        }
    }

}
Running the example:
La Classe DateTime dispose également de méthodes permettant d'ajouter, soustraire des unités de temps, par exemple:
  • AddYears
  • AddDays
  • AddMinutes
  • ...
Example:
AddSubtractExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class AddSubtractExample2
    {
        public static void Main(string[] args)
        {
            // L'heure actuelle.
            DateTime aDateTime = DateTime.Now;

            Console.WriteLine("Now is " + aDateTime);           

            // Ajouter un an.
            DateTime newTime = aDateTime.AddYears(1);


            Console.WriteLine("After add 1 year: " + newTime);

            // Soustraire une heure
            // ​​​​​​​
            newTime = aDateTime.AddHours(-1);

            Console.WriteLine("After add -1 hour: " + newTime);

            Console.Read();
        }
    }

}
Running the example:
Parfois, vous devrez trouver le premier jour ou le dernier jour d’un mois ou un an. Par exemple, vous posez la question en février 2015 est de combien de jours ? 28 ou 29. L’exemple ci-dessous a quelques méthodes utilitaires pour ce faire :
FirstLastDayDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class FirstLastDayDemo
    {
        public static void Main(string[] args)
        {

            Console.WriteLine("Today is " + DateTime.Today);

            DateTime yesterday = GetYesterday();

            Console.WriteLine("Yesterday is " + yesterday);

            // Le premier jour de février 2015
            DateTime aDateTime = GetFistDayInMonth(2015, 2);

            Console.WriteLine("First day of 2-2015: " + aDateTime);

            // Le dernier jour de février 2015
            aDateTime = GetLastDayInMonth(2015, 2);

            Console.WriteLine("Last day of 2-2015: " + aDateTime);

            // Le premier jour de 2015
            aDateTime = GetFirstDayInYear(2015);

            Console.WriteLine("First day year 2015: " + aDateTime);

            // Le dernier jour de 2015
            aDateTime = GetLastDayInYear(2015);

            Console.WriteLine("First day year 2015: " + aDateTime);

            Console.Read();
        }

        // Retourne Hier.
        public static DateTime GetYesterday()
        {
            // Aujourd'hui.
            DateTime today = DateTime.Today;

            // Soustraire un jour.
            return today.AddDays(-1);
        }

        // Renvoie le premier jour de l'année
        public static DateTime GetFirstDayInYear(int year)
        {
            DateTime aDateTime = new DateTime(year, 1, 1);
            return aDateTime;
        }

        // Renvoie le dernier jour de l'année
        public static DateTime GetLastDayInYear(int year)
        {
            DateTime aDateTime = new DateTime(year +1, 1, 1);

            // Soustraire un jour.
            DateTime retDateTime = aDateTime.AddDays(-1);

            return retDateTime;
        }

        // Retournez le premier jour du mois.
        public static DateTime GetFistDayInMonth(int year, int month)
        {
            DateTime aDateTime = new DateTime(year, month, 1);

            return aDateTime;
        }

        // Retournez le dernier jour du mois.
        public static DateTime GetLastDayInMonth(int year, int month)
        {
            DateTime aDateTime = new DateTime(year, month, 1);

            // Ajouter un mois et soustraire un jour.
            // ​​​​​​​
            DateTime retDateTime = aDateTime.AddMonths(1).AddDays(-1);

            return retDateTime;
        }

    }

}
Running the example:

4- Intervalle de temps

Vous avez deux objets DateTime, vous pouvez calculer l'intervalle entre deux sujets, les résultats sont l'objet TimeSpan.
 
IntervalDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class IntervalDemo
    {
        public static void Main(string[] args)
        {
            // L'heure actuelle.
            DateTime aDateTime = DateTime.Now;

            // Temps en 2000
            DateTime y2K = new DateTime(2000,1,1);

            // Intervalle de 2000 jusqu'au aujourd'hui
            TimeSpan interval = aDateTime.Subtract(y2K);


            Console.WriteLine("Interval from Y2K to Now: " + interval);

            Console.WriteLine("Days: " + interval.Days);
            Console.WriteLine("Hours: " + interval.Hours);
            Console.WriteLine("Minutes: " + interval.Minutes);
            Console.WriteLine("Seconds: " + interval.Seconds);
 

            Console.Read();
        }
    }

}
Running the example:

5- Comparaison de deux objets DateTime

DateTime a une méthode statique est Comparer. Méthode utilisée pour comparer deux objets DateTime voir quel sujet est antérieur 
// Si la valeur <0 signifie firstDateTime plus tôt (précéder)
// Si la valeur> 0 signifie secondDateTime plus tôt (précéder).
// Si la valeur = 0 signifie que les deux objets sont les mêmes en termes de temps.
public static int Compare(DateTime firstDateTime, DateTime secondDateTime);
CompareDateTimeExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class CompareDateTimeExample
    {
        public static void Main(string[] args)
        {
            // Heure actuelle.
            DateTime firstDateTime = new DateTime(2000, 9, 2);

            DateTime secondDateTime = new DateTime(2011, 1, 20);

            int compare = DateTime.Compare(firstDateTime, secondDateTime);

            Console.WriteLine("First DateTime: " + firstDateTime);
            Console.WriteLine("Second DateTime: " + secondDateTime);

            Console.WriteLine("Compare value: " + compare);// -1

            if (compare < 0)
            {
                // firstDateTime plus tôt que secondDateTime.
                Console.WriteLine("firstDateTime is earlier than secondDateTime");
            }
            else
            {
                // firstDateTime plus tard que secondDateTime
                Console.WriteLine("firstDateTime is laster than secondDateTime");
            }

            Console.Read();
        }
    }

}
Exécutez l'exemple:

6- Format standard DateTime

Format  Datetime signifie que convertir l'objet  DateTime à une  chaîne, selon un certain motif, par exemple au format jour / mois / année ... ou au format local spécifique.
Les mesthodes  GetDateTimeFormats de  DateTime:
  • Convertir la valeur de cet objet (Datetime) dans une plaque de chaîne formatée, selon les standards sont pris en charge.
AllStandardFormatsDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class AllStandardFormatsDemo
    {
        public static void Main(string[] args)
        {

            DateTime aDateTime = new DateTime(2015, 12, 20, 11, 30, 50);

            // Les formats pris en charge par la date-heure.
            string[] formattedStrings = aDateTime.GetDateTimeFormats();

            foreach (string format in formattedStrings)
            {
                Console.WriteLine(format);
            }


            Console.Read();
        }
    }

}
Running the example:
L'exemple ci-dessus a répertorié les chaînes après avoir formé un objet  DateTime, selon les standards disponibles par .NET. Pour obtenir le format, selon un échantillon, vous utilisez l'une des méthodes suivantes:
Méthode Description
ToString(String, IFormatProvider) Convertir les valeurs de l'objet DateTime présent dans une chaîne représentant son équivalent en utilisant le format donné par le paramètre de String et les informations de parametre de culture(Culture) donnée par le paramètre IFormatProvider.
ToString(IFormatProvider)

Convertir la valeur de l'objet DateTime courant dans string correspondant à la culture de l'information de format (Culture) donnée par le paramètre IFormatProvider.

ToString(String) Convertir la valeur de l'objet DateTime en cours à string équivalente de celui-ci en utilisant le format donné par le paramètre de String et les conventions de mise en forme de la culture actuelle.
L'exemple ci-dessous définit le  DateTime dans le format ' d' et spécifie la culture dans le paramètre.
SimpleDateTimeFormat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Globalization;

namespace DateTimeTutorial
{
    class SimpleDateTimeFormat
    {
        public static void Main(string[] args)
        {

            DateTime aDateTime = new DateTime(2015, 12, 20, 11, 30, 50);

            Console.WriteLine("DateTime: " + aDateTime);

            String d_formatString = aDateTime.ToString("d");

            Console.WriteLine("Format 'd' : " + d_formatString);

            // Un objet décrit la culture américaine (en-US Culture)
            CultureInfo enUs = new CultureInfo("en-US"); 

            // ==> 12/20/2015 (MM/dd/yyyy)
            Console.WriteLine("Format 'd' & en-US: " + aDateTime.ToString("d", enUs));

            // Selon la culture du Vietnam.
            CultureInfo viVn = new CultureInfo("vi-VN");

            // ==> 12/20/2015 (dd/MM/yyyy)
            Console.WriteLine("Format 'd' & vi-VN: " + aDateTime.ToString("d", viVn));


            Console.Read();
        }
    }

}
Running the example:
Les caractères de format standard:
 
Code Pattern
"d" Date courte
"D" Date longue
"f" Heure de la date complète. Court instant.
"F" Heure de la date complète. Longtemps.
"g" Heure de la date générale. Court instant.
"G" Heure de la date générale. Longtemps
"M", 'm" Mois/date.
"O", "o" Round-trip date/time.
"R", "r" RFC1123
"s" temps de date peut être organisé
"t" Temps court
"T" Longtemps
"u" La date peut être organisée, (date et heure universelle Sortable) commune.
"U" Date du long, universel (temps universel complet).
"Y", "y" Année mois
SimpleDateTimeFormatAll.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class SimpleDateTimeFormatAll
    {
        public static void Main(string[] args)
        {
            char[] formats = {'d', 'D','f','F','g','G','M', 'm','O', 'o','R', 'r','s','t','T','u','U','Y', 'y'};


            DateTime aDateTime = new DateTime(2015, 12, 20, 11, 30, 50);

            foreach (char ch in formats)
            {
                Console.WriteLine("\n======" + ch + " ========\n");

                // Les formats date-heure sont pris en charge.
                // ​​​​​​​
                string[] formattedStrings = aDateTime.GetDateTimeFormats(ch);

                foreach (string format in formattedStrings)
                {
                    Console.WriteLine(format);
                }
            }
          


            Console.ReadLine();
        }
    }

}
Running the example

======d ========

12/20/2015
12/20/15
12/20/15
12/20/2015
15/12/20
2015-12-20
20-Dec-15

======D ========

Sunday, December 20, 2015
December 20, 2015
Sunday, 20 December, 2015
20 December, 2015

======f ========

Sunday, December 20, 2015 11:30 AM
Sunday, December 20, 2015 11:30 AM
Sunday, December 20, 2015 11:30
Sunday, December 20, 2015 11:30
December 20, 2015 11:30 AM
December 20, 2015 11:30 AM
December 20, 2015 11:30
December 20, 2015 11:30
Sunday, 20 December, 2015 11:30 AM
Sunday, 20 December, 2015 11:30 AM
Sunday, 20 December, 2015 11:30
Sunday, 20 December, 2015 11:30
20 December, 2015 11:30 AM
20 December, 2015 11:30 AM
20 December, 2015 11:30
20 December, 2015 11:30

======F ========

Sunday, December 20, 2015 11:30:50 AM
Sunday, December 20, 2015 11:30:50 AM
Sunday, December 20, 2015 11:30:50
Sunday, December 20, 2015 11:30:50
December 20, 2015 11:30:50 AM
December 20, 2015 11:30:50 AM
December 20, 2015 11:30:50
December 20, 2015 11:30:50
Sunday, 20 December, 2015 11:30:50 AM
Sunday, 20 December, 2015 11:30:50 AM
Sunday, 20 December, 2015 11:30:50
Sunday, 20 December, 2015 11:30:50
20 December, 2015 11:30:50 AM
20 December, 2015 11:30:50 AM
20 December, 2015 11:30:50
20 December, 2015 11:30:50

======g ========

12/20/2015 11:30 AM
12/20/2015 11:30 AM
12/20/2015 11:30
12/20/2015 11:30
12/20/15 11:30 AM
12/20/15 11:30 AM
12/20/15 11:30
12/20/15 11:30
12/20/15 11:30 AM
12/20/15 11:30 AM
12/20/15 11:30
12/20/15 11:30
12/20/2015 11:30 AM
12/20/2015 11:30 AM
12/20/2015 11:30
12/20/2015 11:30
15/12/20 11:30 AM
15/12/20 11:30 AM
15/12/20 11:30
15/12/20 11:30
2015-12-20 11:30 AM
2015-12-20 11:30 AM
2015-12-20 11:30
2015-12-20 11:30
20-Dec-15 11:30 AM
20-Dec-15 11:30 AM
20-Dec-15 11:30
20-Dec-15 11:30

======G ========

12/20/2015 11:30:50 AM
12/20/2015 11:30:50 AM
12/20/2015 11:30:50
12/20/2015 11:30:50
12/20/15 11:30:50 AM
12/20/15 11:30:50 AM
12/20/15 11:30:50
12/20/15 11:30:50
12/20/15 11:30:50 AM
12/20/15 11:30:50 AM
12/20/15 11:30:50
12/20/15 11:30:50
12/20/2015 11:30:50 AM
12/20/2015 11:30:50 AM
12/20/2015 11:30:50
12/20/2015 11:30:50
15/12/20 11:30:50 AM
15/12/20 11:30:50 AM
15/12/20 11:30:50
15/12/20 11:30:50
2015-12-20 11:30:50 AM
2015-12-20 11:30:50 AM
2015-12-20 11:30:50
2015-12-20 11:30:50
20-Dec-15 11:30:50 AM
20-Dec-15 11:30:50 AM
20-Dec-15 11:30:50
20-Dec-15 11:30:50

======M ========

December 20

======m ========

December 20

======O ========

2015-12-20T11:30:50.0000000

======o ========

2015-12-20T11:30:50.0000000

======R ========

Sun, 20 Dec 2015 11:30:50 GMT

======r ========

Sun, 20 Dec 2015 11:30:50 GMT

======s ========

2015-12-20T11:30:50

======t ========

11:30 AM
11:30 AM
11:30
11:30

======T ========

11:30:50 AM
11:30:50 AM
11:30:50
11:30:50

======u ========

2015-12-20 11:30:50Z

======U ========

Sunday, December 20, 2015 4:30:50 AM
Sunday, December 20, 2015 04:30:50 AM
Sunday, December 20, 2015 4:30:50
Sunday, December 20, 2015 04:30:50
December 20, 2015 4:30:50 AM
December 20, 2015 04:30:50 AM
December 20, 2015 4:30:50
December 20, 2015 04:30:50
Sunday, 20 December, 2015 4:30:50 AM
Sunday, 20 December, 2015 04:30:50 AM
Sunday, 20 December, 2015 4:30:50
Sunday, 20 December, 2015 04:30:50
20 December, 2015 4:30:50 AM
20 December, 2015 04:30:50 AM
20 December, 2015 4:30:50
20 December, 2015 04:30:50

======Y ========

December, 2015

======y ========

December, 2015

DateTime.Parse(string)

Si vous avez une chaîne de date standard, vous pouvez facilement la convertir en  DateTime à l'aide de la méthode statique  DateTime.Parse(string). Normalement, la chaîne de date-heure que vous voyez sur Internet est la chaîne de format standard, la base de données  MySQL ou  SQL  Server utilise également le format standard pour afficher l'heure de la date.
// Les séries chronologiques que vous voyez sur Http Header
string httpTime = "Fri, 21 Feb 2011 03:11:31 GMT";

// Les séries chronologiques que vous voyez sur w3.org
string w3Time = "2016/05/26 14:37:11";

// Les séries chronologiques que vous voyez sur nytimes.com
string nyTime = "Thursday, February 26, 2012";

// Séries temporelles ISO 8601.
string isoTime = "2016-02-10";

// Les séries chronologiques sur la date et l'heure pour créer / modifier un fichier sous Windows.
// ​​​​​​​
string windowsTime = "11/21/2015 11:35 PM";

// Les séries chronologiques sur "Windows Date and Time panel"
string windowsPanelTime = "11:07:03 PM";

7- Personnaliser les formats DateTime

Dans cette section je vous guiderai pour convertir un objet DateTime en une chaîne de format personnalisée, par exemple "dd/MM/yyyy",... et vice versa.
Personnaliser  DateTime -> string:
Utilisez  DateTime.ToString(string):
string format = "dd/MM/yyyy HH:mm:ss";

DateTime now = DateTime.Now;

// ==> 18/03/2016 23:49:39
string s = now.ToString(format);
CustomDateTimeFormatExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class CustomDateTimeFormatExample
    {

        public static void Main(string[] args)
        {
            // Un format de date et d'heure.
            string format = "dd/MM/yyyy HH:mm:ss";

            DateTime now = DateTime.Now;

            string s = now.ToString(format);

            Console.WriteLine("Now: " + s);

            Console.Read();

        }

    }

}
Personnaliser la chaîne -> DateTime 
public static DateTime Parse(string s)

public static DateTime Parse(string s, IFormatProvider provider)

public static DateTime Parse(string s, IFormatProvider provider, DateTimeStyles styles)


public static bool TryParseExact(string s, string format,
           IFormatProvider provider, DateTimeStyles style,
           out DateTime result)

public static bool TryParseExact(string s, string[] formats,
           IFormatProvider provider, DateTimeStyles style,
           out DateTime result)
Example:
Method Example
static DateTime Parse(string) // See also Standard DateTime format.
string httpHeaderTime = "Fri, 21 Feb 2011 03:11:31 GMT";
DateTime.Parse(httpHeaderTime);
static DateTime ParseExact(
  string s,
  string format,
  IFormatProvider provider
)
string dateString = "20160319 09:57";
DateTime.ParseExact(dateString ,"yyyyMMdd HH:mm",null);
static bool TryParseExact(
   string s,
   string format,
   IFormatProvider provider,
   DateTimeStyles style,
   out DateTime result
)
This method is very similar to ParseExact, but it returns a boolean, true if the time series is parsed, otherwise it returns false.
  (See example below).
ParseDateStringExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DateTimeTutorial
{
    class ParseDateStringExample
    {

        public static void Main(string[] args)
        {

            string dateString = "20160319 09:57";

            // Utilisez ParseExact pour analyser une chaîne en DateTime.
            DateTime dateTime = DateTime.ParseExact(dateString, "yyyyMMdd HH:mm", null);

            Console.WriteLine("Input dateString: " + dateString);

            Console.WriteLine("Parse Results: " + dateTime.ToString("dd-MM-yyyy HH:mm:ss"));

            // Une chaîne Datetime avec un espace blanc.
            dateString = "  20110319 11:57";

            // Utilisez la méthode TryParseExact.
            // Cette méthode retourne true si la chaîne « dateString » peut être analysée.
            // Et retourne une valeur pour le paramètre 'out dateTime'.
            bool successful = DateTime.TryParseExact(dateString, "yyyyMMdd HH:mm", null,
                     System.Globalization.DateTimeStyles.AllowLeadingWhite,
                     out dateTime);

            Console.WriteLine("\n------------------------\n");

            Console.WriteLine("Input dateString: " + dateString);

            Console.WriteLine("Can Parse? :" + successful);

            if (successful)
            {
                Console.WriteLine("Parse Results: " + dateTime.ToString("dd-MM-yyyy HH:mm:ss"));
            }


            Console.Read();
        }
    }

}
Running the example:

View more categories: