web-dev-qa-db-fra.com

vérifier si la date date chaîne contient l'heure

J'ai rencontré un problème. J'obtiens une chaîne d'heure date de la base de données et certaines de ces chaînes d'heure date ne contiennent pas l'heure. Mais comme pour la nouvelle exigence, chaque chaîne de date/heure doit contenir l'heure ainsi,

1) 1980/10/11 12:00:01 2) 2010/APRIL/02 17:10:00 3) 10/02/10 03:30:34

La date peut être dans n'importe quel format suivi de l'heure en notation 24hr.

J'ai essayé de détecter l'existence du temps via le code suivant,

string timestamp_string = "2013/04/08 17:30";
DateTime timestamp = Convert.ToDateTime(timestamp_string);
string time ="";

if (timestamp_string.Length > 10)
{
    time = timestamp.ToString("hh:mm");
}
else {
    time = "Time not registered";
}

MessageBox.Show(time);

Mais cela ne fonctionne que pour les horodatages de type No 1). Puis-je savoir comment réaliser cette tâche sur la manière de détecter si l'élément time existe dans cette chaîne d'heure date/heure. Merci beaucoup :)

MATCH POSSIBLE Comment valider si une chaîne "date et heure" a seulement une heure?

INFOles trois réponses fournies par Arun Selva Kumar, Guru Kara, Patipol Paripoonnanonda sont toutes correctes, vérifie l'heure et me sert à la tâche. Mais je sélectionne Guru Karas répondre uniquement sur la facilité d'utilisation et l'explication qu'il a donnée. Merci beaucoup :) très apprécié vous tous :)

c#datetimetime
18
Hasitha Shan

Les composants date/heure TimeOfDay est ce dont vous avez besoin.

MSDN indique "Contrairement à la propriété Date, qui renvoie une valeur DateTime qui représente une date sans son composant heure, la propriété TimeOfDay renvoie une valeur TimeSpan qui représente le composant heure d'une valeur DateTime."

Voici un exemple prenant en compte tous vos scénarios.
Puisque vous êtes sûr du format, vous pouvez utiliser DateTime.Parse sinon veuillez utiliser DateTime.TryParse

var dateTime1 = System.DateTime.Parse("1980/10/11 12:00:00");
var dateTime2 = System.DateTime.Parse("2010/APRIL/02 17:10:00");
var dateTime3 = System.DateTime.Parse("10/02/10 03:30:34");
var dateTime4 = System.DateTime.Parse("02/20/10");

if (dateTime1.TimeOfDay.TotalSeconds == 0) {
    Console.WriteLine("1980/10/11 12:00:00 - does not have Time");
} else {
    Console.WriteLine("1980/10/11 12:00:00 - has Time");
}

if (dateTime2.TimeOfDay.TotalSeconds == 0) {
    Console.WriteLine("2010/APRIL/02 17:10:00 - does not have Time");
} else {
    Console.WriteLine("2010/APRIL/02 17:10:00 - Has Time");
}

if (dateTime3.TimeOfDay.TotalSeconds == 0) {
    Console.WriteLine("10/02/10 03:30:34 - does not have Time");
} else {
    Console.WriteLine("10/02/10 03:30:34 - Has Time");
}

if (dateTime4.TimeOfDay.TotalSeconds == 0) {
    Console.WriteLine("02/20/10 - does not have Time");
} else {
    Console.WriteLine("02/20/10 - Has Time");
}
20
Guru Kara

Essaye ça, 

DateTime myDate;
if (DateTime.TryParseExact(inputString, "dd-MM-yyyy hh:mm:ss", 
    CultureInfo.InvariantCulture, DateTimeStyles.None, out myDate))
{
    //String has Date and Time
}
else
{
    //String has only Date Portion    
}

Vous pouvez essayer d’utiliser d’autres spécificateurs de format tels qu’énumérés ici, http://msdn.Microsoft.com/en-us/library/8kb3ddd4.aspx

9
Arun Selva Kumar

En combinant les réponses de Guru Kara et Patipol Paripoonnanonda avec l’API de mondialisation .net, on obtient:

bool HasExplicitTime(DateTime parsedTimestamp, string str_timestamp)
{
    string[] dateTimeSeparators = { "T", " ", "@" };
    string[] timeSeparators = {
        CultureInfo.CurrentUICulture.DateTimeFormat.TimeSeparator,
        CultureInfo.CurrentCulture.DateTimeFormat.TimeSeparator,
        ":"};

    if (parsedTimestamp.TimeOfDay.TotalSeconds != 0)
        return true;

    string[] dateOrTimeParts = str_timestamp.Split(
            dateTimeSeparators,
            StringSplitOptions.RemoveEmptyEntries);
    bool hasTimePart = dateOrTimeParts.Any(part =>
            part.Split(
                    timeSeparators,
                    StringSplitOptions.RemoveEmptyEntries).Length > 1);
    return hasTimePart;
}

Cette approche:

  • détecte les heures de minuit explicites (par exemple, "2015-02-26T00: 00");
  • recherche uniquement dans la chaîne lorsque TimeOfDay indique minuit ou aucune heure explicite; et
  • trouve les heures de minuit explicites au format local et toutes les heures autres que minuit dans tous les formats pouvant être analysés par .net.

Limites:

  • les heures de minuit explicites au format local non culturel ne sont pas détectées; 
  • les heures de minuit explicites comportant moins de deux parties ne sont pas détectées; et
  • moins simple et élégant que les approches de Guru Kara et Patipol Paripoonnanonda.
3
Kasper van den Berg

Voici ce que je vais avec pour l'instant. Ce n'est peut-être pas parfait, mais probablement mieux que de considérer n'importe quelle heure datée de 12 heures comme n'ayant pas l'heure. La prémisse est que si je pointe une spécification à temps plein à la fin, elle sera analysée s'il ne s'agit que d'une date mais échouera si elle a déjà une composante de temps. 

Je devais supposer qu'il n'y avait pas de date/heure valide comportant 7 caractères non blancs ou moins. Il semble que "1980/10" soit analysé, mais pas "1980/10 01: 01: 01.001".

J'ai inclus divers cas de test. N'hésitez pas à ajouter les vôtres et à me faire savoir s'ils échouent.

public static bool IsValidDateTime(this string dateString, bool requireTime = false)
{
    DateTime outDate;
    if(!DateTime.TryParse(dateString, out outDate)) return false;

    if (!requireTime) return true;
    else
    {
        return Regex.Replace(dateString, @"\s", "").Length > 7 
&& !DateTime.TryParse(dateString + " 01:01:01.001", out outDate);
    }
}

public void DateTest()
{
    var withTimes = new[]{
    "1980/10/11 01:01:01.001",
    "02/01/1980 01:01:01.001",
    "1980-01-01 01:01:01.001",
    "1980/10/11 00:00",
    "1980/10/11 1pm",
    "1980-01-01 00:00:00"};

    //Make sure our ones with time pass both tests
    foreach(var date in withTimes){
        Assert.IsTrue(date.IsValidDateTime(), String.Format("date: {0} isn't valid.", date));
        Assert.IsTrue(date.IsValidDateTime(true), String.Format("date: {0} does have time.", date));
    }

    var withoutTimes = new[]{
    "1980/10/11",
    "1980/10",
    "1980/10 ",
    "10/1980",
    "1980 01",
    "1980/10/11 ",
    "02/01/1980",
    "1980-01-01"};

    //Make sure our ones without time pass the first and fail the second
    foreach (var date in withoutTimes)
    {
        Assert.IsTrue(date.IsValidDateTime(), String.Format("date: {0} isn't valid.", date));
        Assert.IsFalse(date.IsValidDateTime(true), String.Format("date: {0} doesn't have time.", date) );
    }

    var bogusTimes = new[]{
    "1980",
    "1980 01:01",
    "80 01:01",
    "1980T01",
    "80T01:01",
    "1980-01-01T01",
    };

    //Make sure our ones without time pass the first and fail the second
    foreach (var date in bogusTimes)
    {
        DateTime parsedDate;
        DateTime.TryParse(date, out parsedDate);
        Assert.IsFalse(date.IsValidDateTime(), String.Format("date: {0} is valid. {1}", date, parsedDate));
        Assert.IsFalse(date.IsValidDateTime(true), String.Format("date: {0} is valid. {1}", date, parsedDate));
    }
}
0
Zephryl