Comment utiliser DateTime.TryParse avec un <DateTime> Nullable?

Je souhaite utiliser la méthode DateTime.TryParse pour obtenir la valeur datetime d'une chaîne dans un Nullable. Mais quand j'essaye ceci:

DateTime? d;
bool success = DateTime.TryParse("some date text", out (DateTime)d);

le compilateur me dit

L'argument 'out' n'est pas classé comme une variable

Je ne sais pas ce que je dois faire ici. J'ai aussi essayé:

out (DateTime)d.Value 

et cela ne fonctionne pas non plus. Des idées?

DateTime? d=null;
DateTime d2;
bool success = DateTime.TryParse("some date text", out d2);
if (success) d=d2;

(Il peut y avoir des solutions plus élégantes, mais pourquoi ne faites-vous pas simplement quelque chose comme ci-dessus?)

Comme le dit Jason, vous pouvez créer une variable du bon type et la transmettre. Vous voudrez peut-être l'encapsuler dans votre propre méthode:

public static DateTime? TryParse(string text)
{
    DateTime date;
    if (DateTime.TryParse(text, out date))
    {
        return date;
    }
    else
    {
        return null;
    }
}

... ou si vous aimez l'opérateur conditionnel:

public static DateTime? TryParse(string text)
{
    DateTime date;
    return DateTime.TryParse(text, out date) ? date : (DateTime?) null;
}

Ou en C # 7:

public static DateTime? TryParse(string text) =>
    DateTime.TryParse(text, out var date) ? date : (DateTime?) null;

Voici une édition légèrement concise de ce que Jason a suggéré:

DateTime? d; DateTime dt;
d = DateTime.TryParse(DateTime.Now.ToString(), out dt)? dt : (DateTime?)null;

Vous ne pouvez pas parce que Nullable<DateTime>c'est un type différent de DateTime. Vous devez écrire votre propre fonction pour le faire,

public bool TryParse(string text, out Nullable<DateTime> nDate)
{
    DateTime date;
    bool isParsed = DateTime.TryParse(text, out date);
    if (isParsed)
        nDate = new Nullable<DateTime>(date);
    else
        nDate = new Nullable<DateTime>();
    return isParsed;
}

J'espère que cela t'aides :)

EDIT: Suppression de la méthode d'extension (évidemment) mal testée, car (comme souligné par certains mauvais hoor) les méthodes d'extension qui tentent de modifier le paramètre "this" ne fonctionneront pas avec les types de valeur.

PS The Bad Hoor en question est un vieil ami :)

Qu'en est-il de la création d'une méthode d'extension?

public static class NullableExtensions
{
    public static bool TryParse(this DateTime? dateTime, string dateString, out DateTime? result)
    {
        DateTime tempDate;
        if(! DateTime.TryParse(dateString,out tempDate))
        {
            result = null;
            return false;
        }

        result = tempDate;
        return true;

    }
}

Je ne vois pas pourquoi Microsoft n'a pas géré cela. Une petite méthode utilitaire intelligente pour gérer cela (j'ai eu le problème avec int, mais remplacer int par DateTime aura le même effet, pourrait être .....

    public static bool NullableValueTryParse(string text, out int? nInt)
    {
        int value;
        if (int.TryParse(text, out value))
        {
            nInt = value;
            return true;
        }
        else
        {
            nInt = null;
            return false;
        }
    }

C'est la seule doublure que vous recherchez pour:

DateTime? d = DateTime.TryParse("some date text", out DateTime dt) ? dt : null;

Si vous voulez en faire une méthode de pseudo-extension TryParse appropriée, vous pouvez le faire:

public static bool TryParse(string text, out DateTime? dt)
{
    if (DateTime.TryParse(text, out DateTime date))
    {
        dt = date;
        return true;
    }
    else
    {
        dt = null;
        return false;
    }
}

Voici une solution sur une seule ligne:

DateTime? d = DateTime.TryParse("text", out DateTime parseDate) ? parseDate : (DateTime?)null;

Sinon, si vous n'êtes pas concerné par la possible exception déclenchée, vous pouvez modifier TryParse pour Parse:

DateTime? d = DateTime.Parse("some valid text");

Bien qu'il n'y ait pas non plus de booléen indiquant le succès, cela peut être pratique dans certaines situations où vous savez que le texte d'entrée sera toujours valide.